懒惰评估使Meyers的Singleton线程安全快速

Question

So i read a lot about why this implementation isn't thread-safe. But I didn't find the answer how to make it thread safe and fast? The variant of make it thread safe is to add mutex(or in some cases just critical section will be enough), but it will make this method much more slower. So is there a variant to make this code thread safe and fast, or at least now as slow as adding mutex there?

static Singleton& getInstance()
{
     static Singleton singleton;
     return singleton;
}

PS: and yes, I also read a lot about thread safe Singletom implementation when we use Singleton pointer as a member of the class, the question is about this particular implementation of Singleton, without pointers and new and using lazy evaluation.

Answer 1

For some compilers what you have may already have a threadsafe guarantee. If you don't care about code portability and it works for you, then be happy with it.

If you have boost thread available you can use boost::call_once to initialise. This is threadsafe and only costs on first initialisation.

You can of course also make a "Meyers" singleton creation totally thread-safe by initialising it, ie accessing it the first time, before you create threads that access it. If you have lots of these singletons already implemented consider doing that.

All of these, even boost::call_once only applies to the creation of the object. Its access, however, may need separate synchronisation techniques if accessed by multiple threads.

(Incidentally Item 47 of Meyers Effective C++ where this singleton is mentioned suggests that later revisions of the standard made it thread-safe and later compilers conformed with it, however it does warn you that not all compilers are compliant yet).

Answer 2

OK, so you can't do it without a mutex at all, but you can make that mutex fast.

First declare a class to hold the mutex, and a ready flag ( InitMutex below). When GrabMutex() is called and ready is false , the actual mutex is grabbed. When ReleaseMutex() is called it does the right thing based on the flag sent from GrabMutex() . After the first time through, ready goes true as the static object is now initialized, so the mutex doesn't need to be grabbed.

Now, declare a class which calls GrabMutex() in the constructor and ReleaseMutex(flag) in the destructor, saving the flag locally ( InitMutexHolder below).

Now, instantiate that class inside your regular getSingleton function. This will ensure that the singleton initialization is mutexed the first time through, and if multiple threads contend they will line up on the mutex. But once the singleton is initialized, ready goes true, and access will be fast. The destructor is called magically after return theSingleton is executed, which releases the mutex (or does nothing if the mutex was not taken).

But, the main body of code in your theSingleton() function is unchanged, we have only added a control object per singleton, and a stack object in the call which manages the thread safety.

Note about write barriers: since the code is safe whenever ready is false, and ready can't go true until the object is initialized, the code is overall safe assuming that writes are instantly visible. But, there may be a delay in ready=true being visible, since there is no write barrier after setting ready true. However, during that delay safety is still maintained, since ready=false is the conservative, safe case.

class InitMutex
{
public:
   InitMutex() : ready(false) { }

   bool  GrabMutex()
   {
      if (!ready)
      {
         mutex.Grab();
         return true;
      }
      else
      {
         return false;
      }
   }

   void ReleaseMutex(bool flagFromGrabMutex)
   {
      if (flagFromGrabMutex)
      {
          mutex.Release();
          ready = true;
      }
   }

   Mutex   mutex;
   bool    ready;
};

class InitMutexHolder
{
public:
    InitMutexHolder(InitMutex & m)
    : initMutex(m)
    {
       inMutex = initMutex.GrabMutex();
    }
    ~InitMutexHolder()
    {
       initMutex.ReleaseMutex(inMutex);
    }

private:
    bool inMutex;
    InitMutex & initMutex;
};

static InitMutex singletonMutex;
static Singleton & getSingleton()
{
    InitMutexHolder mutexHolder(singletonMutex);
    {
       static Singleton theSingleton;
       return theSingleton;
    }   
}

Answer 3

So seems the answer to my question best expressed Fred Larson in his comment:

"Fast, thread-safe, lazy - pick any two."