便携式线程安全懒惰单身人士

祝福大家。 我正在尝试编写一个线程安全的单身人士以供将来使用。这是我能想到的最好的。任何人都可以发现任何问题吗？关键假设是静态初始化发生在动态初始化之前的单个线程中。 (这将用于商业项目和公司不使用提振:(生活将是一件轻而易举的事情:)否则:) PS：还没有检查这个编译，我的道歉。

/*
There are two difficulties when implementing the singleton pattern:
Problem (a):  The "global variable instantiation fiasco". TODO: URL
This is due to the unspecified order in which global variables are initialised. Static class members are equivalent
to a global variable in C++ during initialisation.
Problem (b):  Multi-threading.
Care must be taken to ensure that the mutex initialisation is handled properly with respect to problem (a).
*/
/*
Things achieved, maybe:
*) Portable
*) Lazy creation.
*) Safe from unspecified order of global variable initialisation.
*) Thread-safe.
*) Mutex is properly initialise when invoked during global variable intialisation:
*) Effectively lock free in instance().
*/
/************************************************************************************
Platform dependent mutex implementation
*/
class Mutex
{
public:
 void lock();
 void unlock();
};
/************************************************************************************
Threadsafe singleton
*/
class Singleton
{
public:  // Interface
 static Singleton* Instance();
private:  // Static helper functions
static Mutex* getMutex();
private:  // Static members
static Singleton* _pInstance;
static Mutex* _pMutex;
private:  // Instance members
bool* _pInstanceCreated;  // This is here to convince myself that the compiler is not re-ordering instructions.
private:  // Singletons can't be coppied
explicit Singleton();
 ~Singleton() { }
};
/************************************************************************************
We can't use a static class member variable to initialised the mutex due to the unspecified
order of initialisation of global variables.
Calling this from
*/
Mutex* Singleton::getMutex()
{
 static Mutex* pMutex = 0;  // alternatively:  static Mutex* pMutex = new Mutex();
 if( !pMutex )
 { 
  pMutex = new Mutex();  // Constructor initialises the mutex: eg. pthread_mutex_init( ... )
 }
return pMutex;
}
/************************************************************************************
This static member variable ensures that we call Singleton::getMutex() at least once before
the main entry point of the program so that the mutex is always initialised before any threads
are created.
*/
Mutex* Singleton::_pMutex = Singleton::getMutex();
/************************************************************************************
Keep track of the singleton object for possible deletion.
*/
Singleton* Singleton::_pInstance = Singleton::Instance();
/************************************************************************************
Read the comments in Singleton::Instance().
*/
Singleton::Singleton( bool* pInstanceCreated )
{
 fprintf( stderr, "Constructor\n" );
_pInstanceCreated = pInstanceCreated; 
}
/************************************************************************************
Read the comments in Singleton::Instance().
*/
void Singleton::setInstanceCreated()
{
 _pInstanceCreated = true;
}
/************************************************************************************
Fingers crossed.
*/
Singleton* Singleton::Instance()
{
 /*
'instance' is initialised to zero the first time control flows over it. So
 avoids the unspecified order of global variable initialisation problem.
*/ 
 static Singleton* instance = 0;
/*
 When we do:
instance = new Singleton( instanceCreated );
the compiler can reorder instructions and any way it wants as long
 as the observed behaviour is consistent to that of a single threaded environment ( assuming
 that no thread-safe compiler flags are specified). The following is thus not threadsafe:
if( !instance )
 {
  lock();
  if( !instance )
  {
   instance = new Singleton( instanceCreated );
  }
  lock();
 }
Instead we use:
static bool instanceCreated = false;
as the initialisation indicator.
 */
 static bool instanceCreated = false;
/*
Double check pattern with a slight swist.
*/
 if( !instanceCreated )
 {
  getMutex()->lock();
  if( !instanceCreated )
  {
   /*
   The ctor keeps a persistent reference to 'instanceCreated'.
In order to convince our-selves of the correct order of initialisation (I think
   this is quite unecessary
   */
   instance = new Singleton( instanceCreated );
/*
   Set the reference to 'instanceCreated' to true.
Note that since setInstanceCreated() actually uses the non-static
   member variable: '_pInstanceCreated', I can't see the compiler taking the
   liberty to call Singleton's ctor AFTER the following call. (I don't know
   much about compiler optimisation, but I doubt that it will break up the ctor into
   two functions and call one part of it before the following call and the other part after.
   */
   instance->setInstanceCreated();
/*
   The double check pattern should now work.
   */
  }  
  getMutex()->unlock();
 }
return instance;
}