efficient thread-safe singleton in C++

Question

The usual pattern for a singleton class is something like

static Foo &getInst() {   static Foo *inst = NULL;   if(inst == NULL)     inst = new Foo(...);   return *inst;     } 

However, it's my understanding that this solution is not thread-safe, since 1) Foo's constructor might be called more than once (which may or may not matter) and 2) inst may not be fully constructed before it is returned to a different thread.

One solution is to wrap a mutex around the whole method, but then I'm paying for synchronization overhead long after I actually need it. An alternative is something like

static Foo &getInst() {   static Foo *inst = NULL;   if(inst == NULL)   {     pthread_mutex_lock(&mutex);     if(inst == NULL)       inst = new Foo(...);     pthread_mutex_unlock(&mutex);   }   return *inst;     } 

Is this the right way to do it, or are there any pitfalls I should be aware of? For instance, are there any static initialization order problems that might occur, i.e. is inst always guaranteed to be NULL the first time getInst is called?

Answer 1

If you are using C++11, here is a right way to do this:

Foo& getInst() {     static Foo inst(...);     return inst; } 

According to new standard there is no need to care about this problem any more. Object initialization will be made only by one thread, other threads will wait till it complete. Or you can use std::call_once. (more info here)