Storage durations

__declspec(thread) MyClass* tls_ptr = nullptr;
...
void SomeThreadFunc()
{
    if (!tls_ptr) 
        tls_ptr = new MyClass();
    ...
}

__declspec(thread) MyClass* tls_ptr = nullptr;
...
void SomeThreadFunc()
{
    if (!tls_ptr) 
        tls_ptr = new MyClass();
    ...
 
    delete tls_ptr;
}

#include <iostream>
#include <sstream>
#include <vector>
#include <thread>
#include <mutex>
 
namespace detail{
 
    #define dFOR__(char_) \
        typename std::enable_if< std::is_same<typename T::char_type, char_>::value,
 
    #define THIS_OBJECT__(obj_) \
        decltype(obj_)>::type& { return obj_; }
 
    template<class T> auto ostream__() -> dFOR__(char) 
        THIS_OBJECT__(std::cout);
 
    template<class T> auto ostream__() -> dFOR__(wchar_t) 
        THIS_OBJECT__(std::wcout);
 
    #undef THIS_OBJECT__
    #undef dFOR__
 
}//detail
 
template<class T> class AtomicStream
{
    typedef std::mutex 
        mutex_t;
 
    typedef std::basic_ostringstream<typename T::char_type>
        accumulator_t;
public:
    AtomicStream(T& s = detail::ostream__<T>() )
        : mMutex(), mStream(), mDst(s){}
 
   ~AtomicStream(){
        mMutex.lock();
        mDst << mStream.str();
        mMutex.unlock();
    }
 
    template<class U> accumulator_t& operator << (U&& v) { 
        return mStream << v, mStream;
    }
private:
    mutex_t       mMutex;
    accumulator_t mStream;
    T&            mDst;
};
 
typedef AtomicStream<std::ostream>
    AStream;
typedef AtomicStream<std::wostream>
    WAStream;
 
 
 
//------------------------------------------------------
 
 
#define dME \
    " -----------------------------> "   \
    "sample(" << std::this_thread::get_id() << ")"
 
struct sample {
    sample() { AStream() << dME " was build"     << std::endl; }
   ~sample() { AStream() << dME " was destroyed" << std::endl; }
};
 
#undef dME
 
thread_local sample gObj;
 
 
void atomic_print(const std::string& name, const size_t indx)
{
    AStream() << "thread(" << std::this_thread::get_id() << ") "<< name
        << " printing: " << indx 
        << std::endl;
}
 
void threadFunction(const std::string& name)
{
    for(size_t n=0;n<5; ++n)
        atomic_print(name, n);
    
    AStream() << "thread(" << std::this_thread::get_id() << ") "<< name
        << " was finished!"
        << std::endl;
}
 
 
 
int main()
{
    std::cout << "Hello, world!\n";
    
    const char* names[] = { "one", "two", "foo", "bar", "baz" };
    
    std::vector<std::thread> threads;
    for(size_t n=0; n< 5; ++n)
        threads.emplace_back(&threadFunction, names[n] );
 
    for(size_t n=0; n<5; ++n)
        threads[n].join();
    
    AStream() << "finished!"<<std::endl;
}

// --- эту функцию будем вызывать для каждого потока
// в момент его завершения
void Stop()
{
    const auto id
        = std::this_thread::get_id();
    service::AStream() << "[" << id << "] finished\n";
}
 
// --- последняя задача для тред-пула
// она должна просигналить пулу о том,
// что нужно остановиться
void Finish()
{
    service::AStream() << "[ALL TASK FINISHED]\n";
 
    // --- иногда по факту завершению работы потока
    // необходимо выполнить дополнительную функцию-зачистки
    // например, если требуется доступ к TLS (thread local storage) данным
    // в этом случае можно указать дополнительную функцию
    // которая будет вызвана для каждого остановившегося потока
 
    // если такая зачистка не нужна
    // то можно вызвать Stop() без аргументов
    service::ThreadPool::Get().Stop(::Stop);
}