// header file
class  SomeSingleton
{
private:
 SomeSingleton();
public:
 static SomeSingleton& Instance();
};

// cpp file
SomeSingleton& SomeSingleton::Instance()
{
 static SomeSingleton Singl;

 return Singl;
}

// cpp file
SomeSingleton& SomeSingleton::Instance()
{
 SomeLocker(....);

 static SomeSingleton Singl;

 return Singl;
}

LM>// cpp file
LM>SomeSingleton& SomeSingleton::Instance()
LM>{
LM> SomeLocker(....);

LM> static SomeSingleton Singl;

LM> return Singl;
LM>}

LM>

class Singleton
{
static Singleton* pInst_;
public:
static Singleton& Instance();
};

Singleton* Singleton::pInst_ = 0;

Singleton& Singleton::Instance()
{
   if(pInst_)
      return *pInst_;

   SomeLocker Lock(....);
   static Singleton obj;
   pInst_ = &obj;
   return obj;
}

Singleton& Singleton::Instance()
{
   if(pInst_)
      return *pInst_;

   SomeLocker Lock(....);
   if(pInst_)//Вот она, вторая проверка :-/
      return *pInst_;

   static Singleton obj;
   pInst_ = &obj;
   return obj;
}

volatile sig_atomic_t integer

The compiler now uses the library interface specified by the C++ ABI for thread-safe initialization of function-scope static variables. Most users should leave this alone, but embedded programmers may want to disable this by specifying -fno-threadsafe-statics for a small savings in code size.

Data& init_instance()
{
  static Data data;
  // медленно и печально работаем
  .....
  return data;
}

Data& instance = init_instance();