Question

I’ve been reading about thread-safe singleton patterns here:

http://en.wikipedia.org/wiki/Singleton_pattern#C.2B.2B_.28using_pthreads.29

And it says at the bottom that the only safe way is to use pthread_once – which isn’t available on Windows.

Is that the only way of guaranteeing thread safe initialisation?

I’ve read this thread on SO:

Thread safe lazy construction of a singleton in C++

And seems to hint at an atomic OS level swap and compare function, which I assume on Windows is:

http://msdn.microsoft.com/en-us/library/ms683568.aspx

Can this do what I want?

Edit: I would like lazy initialisation and for there to only ever be one instance of the class.

Someone on another site mentioned using a global inside a namespace (and he described a singleton as an anti-pattern) – how can it be an ‘anti-pattern’?

Accepted Answer:
I’ve accepted Josh’s answer as I’m using Visual Studio 2008 – NB: For future readers, if you aren’t using this compiler (or 2005) – Don’t use the accepted answer!!

Edit: The code works fine except the return statement – I get an error: error C2440: ‘return’ : cannot convert from ‘volatile Singleton *’ to ‘Singleton *’. Should I modify the return value to be volatile Singleton *?

Edit: Apparently const_cast<> will remove the volatile qualifier. Thanks again to Josh.

Answer 1

If you are are using Visual C++ 2005/2008 you can use the double checked locking pattern, since ‘volatile variables behave as fences‘. This is the most efficient way to implement a lazy-initialized singleton.

From MSDN Magazine:

Singleton* GetSingleton() {     volatile static Singleton* pSingleton = 0;      if (pSingleton == NULL)     {         EnterCriticalSection(&cs);          if (pSingleton == NULL)         {             try             {                 pSingleton = new Singleton();             }             catch (...)             {                 // Something went wrong.             }         }          LeaveCriticalSection(&cs);     }      return const_cast<Singleton*>(pSingleton); } 

Whenever you need access to the singleton, just call GetSingleton(). The first time it is called, the static pointer will be initialized. After it’s initialized, the NULL check will prevent locking for just reading the pointer.

DO NOT use this on just any compiler, as it’s not portable. The standard makes no guarantees on how this will work. Visual C++ 2005 explicitly adds to the semantics of volatile to make this possible.

You’ll have to declare and initialize the CRITICAL SECTION elsewhere in code. But that initialization is cheap, so lazy initialization is usually not important.