Here is a working example code for MSVC++ 8>:
______________________________________________________________________________
/* POSIX Threads (pthread-win32) / MSVC Singleton
____________________________________________________________________*/
#include <pthread.h>
#include <cassert>
#include <cstdio>
#if defined(_MSC_VER)
# define DECLSPEC_THREAD static __declspec(thread)
# define DEFSPEC_THREAD __declspec(thread)
# define DECLSPEC_CDECL __cdecl
# define DEFSPEC_CDECL __cdecl
#else
# define DECLSPEC_THREAD __thread
# define DEFSPEC_THREAD
# define DECLSPEC_CDECL __attribute__((cdecl))
# define DEFSPEC_CDECL __attribute__((cdecl))
#endif
namespace posix {
namespace thread {
template<typename T>
class once {
DECLSPEC_THREAD T* g_tls;
static T* g_instance;
static pthread_once_t g_once;
static void DECLSPEC_CDECL prv_init();
public:
static T& instance();
};
template<typename T>
DEFSPEC_THREAD T* once<T>::g_tls = NULL;
template<typename T>
T* once<T>::g_instance = NULL;
template<typename T>
pthread_once_t once<T>::g_once = PTHREAD_ONCE_INIT;
template<typename T>
void DECLSPEC_CDECL once<T>:
rv_init() {
static T g_obj;
assert(! g_instance);
g_instance = &g_obj;
std:
rintf("INSTANCE SLOW-PATH STATIC INIT! <(%p)->g_instance>\n",
(void*)g_instance);
}
template<typename T>
T& once<T>::instance() {
if (! g_tls) {
int const status = pthread_once(&g_once, prv_init);
if (status) {
assert(! status);
throw;
}
g_tls = g_instance;
if (! g_tls) {
assert(g_tls);
throw;
}
std:
rintf("INSTANCE SLOW-PATH! <(%p)->g_tls == (%p)->g_instance>\n",
(void*)g_tls, (void*)g_instance);
} else {
std:
rintf("INSTANCE FAST-PATH! <(%p)->g_tls == (%p)->g_instance>\n",
(void*)g_tls, (void*)g_instance);
assert(g_tls == g_instance);
}
return *g_tls;
}
// abstract thread
class thread_base {
pthread_t m_handle;
virtual void on_active() = 0;
static void* DEFSPEC_CDECL prv_active(void* state) {
static_cast<thread_base*>(state)->on_active();
return 0;
}
public:
virtual ~thread_base() = 0;
void active_run() {
pthread_create(&m_handle, NULL, prv_active, this);
}
void active_join() {
pthread_join(m_handle, NULL);
}
};
thread_base::~thread_base() {}
}} // namespace posix::thread
// active helper
template<typename T>
struct active : public T {
active() : T() {
active_run();
}
template<typename P1>
active(P1 p1) : T(p1) {
active_run();
}
~active() {
active_join();
}
};
/* Sample Application
____________________________________________________________________*/
// abstract the namespace
namespace mythread = posix::thread;
template<unsigned TYPE>
struct foo {
foo() {
std:
rintf("(%p)->foo<%u>::foo()\n", (void*)this, TYPE);
}
~foo() {
std:
rintf("(%p)->foo<%u>::~foo()\n", (void*)this, TYPE);
std:
uts("hit <ENTER> to continue...");
std::fflush(stdout);
std::getchar();
}
void do_something(unsigned thread_id) {
std:
rintf("(%p)->foo<%u>::do_something() called by (%u)\n",
(void*)this, TYPE, thread_id);
}
};
class worker : public mythread::thread_base {
unsigned const m_id;
void on_active() {
std:
rintf("(%p)->worker(%u):
n_active() - enter\n", (void*)this,
m_id);
for (unsigned i = 0; i < 10; ++i) {
if (! (i % 2)) {
mythread:
nce<foo<0> >::instance().do_something(m_id);
mythread:
nce<foo<1> >::instance().do_something(m_id);
mythread:
nce<foo<2> >::instance().do_something(m_id);
mythread:
nce<foo<3> >::instance().do_something(m_id);
mythread:
nce<foo<3> >::instance().do_something(m_id);
mythread:
nce<foo<2> >::instance().do_something(m_id);
mythread:
nce<foo<1> >::instance().do_something(m_id);
mythread:
nce<foo<0> >::instance().do_something(m_id);
} else {
mythread:
nce<foo<4> >::instance().do_something(m_id);
mythread:
nce<foo<5> >::instance().do_something(m_id);
mythread:
nce<foo<6> >::instance().do_something(m_id);
mythread:
nce<foo<7> >::instance().do_something(m_id);
mythread:
nce<foo<7> >::instance().do_something(m_id);
mythread:
nce<foo<6> >::instance().do_something(m_id);
mythread:
nce<foo<5> >::instance().do_something(m_id);
mythread:
nce<foo<4> >::instance().do_something(m_id);
}
}
std:
rintf("(%p)->worker(%u):
n_active() - exit\n", (void*)this,
m_id);
}
public:
worker(unsigned const id) : m_id(id) {}
};
int main(void) {
{
active<worker> workers[] = { 123, 456, 789, 213, 645, 978, 543, 1024 };
}
return 0;
}
______________________________________________________________________________
This should compile fine. You need the `pthread-win32' library for this to
work on windows. No reason why this would not work on pure POSIX system with
compiler that had similar extensions.
