C++单例模式以及线程安全

class MySingleton
{
public:
static MySingleton * GetInstance()
//static method that returns only instance of MySingletone
{
if (m_pOnlyOneInstance == NULL) // if not yet instantiated
{
m_pOnlyOneInstance = new MySingleton();
//create one and only object
}

return m_pOnlyOneInstance;
}

private:

static MySingleton * m_pOnlyOneInstance;
//holds one and only object of MySingleton

MySingleton(); // private constructor

public:
// MySingleton functionalities
void foo();
bool goo();
int zoo();
};

MySingleton * GetInstance() //usage of critcal section makes it thread safe
{
EnterCriticalSection();
//other client threads, if any, now have to wait till current
// thread leaves critical section. Forget semantics and
// compilation for Crit Section, and treat this as pseudo-code
if (m_pOnlyOneInstance == NULL)
{
m_pOnlyOneInstance = new MySingleton();
}

LeaveCriticalSection();

return m_pOnlyOneInstance;
}

#ifndef SINGLETON_H_
#define SINGLETON_H_

#include <cassert>
#include <boost/thread/mutex.hpp>

template<class T>
class Singleton
{
public:
static T& GetInstance()
{
assert(!is_destructed);
(void)is_destructed; // prevent removing is_destructed in Release configuration

boost::mutex::scoped_lock lock(GetMutex());
static T instance;
return instance;
}

private:
static bool is_destructed;

static boost::mutex& GetMutex()
{
static boost::mutex mutex;
return mutex;
}

Singleton() {}
~Singleton() { is_destructed = true; }
};

// force creating mutex before main() is called
template<class T>
bool Singleton<T>::is_destructed = (Singleton<T>::GetMutex(), false);

#endif // SINGLETON_H_

#include <iostream>
#include <atomic>
#include <mutex>
using namespace std;

class Foo {
public:
static Foo* Instance();
private:
Foo() {init();}
void init() { cout << "init done." << endl;} // your init cache function.
static atomic<Foo*> pinstance;
static mutex m_;
};

atomic<Foo*> Foo::pinstance { nullptr };
std::mutex Foo::m_;

Foo* Foo::Instance() {
if(pinstance == nullptr) {
lock_guard<mutex> lock(m_);
if(pinstance == nullptr) {
pinstance = new Foo();
}
}
return pinstance;
}

int main() {
Foo* foo1 = Foo::Instance();
Foo* foo2 = Foo::Instance();
return 0;
}

#include <memory>
#include <mutex>

class CSingleton
{
public:
virtual ~CSingleton();
static CSingleton& GetInstance();

private:
static std::unique_ptr<CSingleton> m_instance;
static std::once_flag m_onceFlag;
CSingleton(void);
CSingleton(const CSingleton& src);
CSingleton& operator=(const CSingleton& rhs);
};

std::unique_ptr<CSingleton> CSingleton::m_instance;
std::once_flag CSingleton::m_onceFlag;

CSingleton& CSingleton::GetInstance()
{
std::call_once(m_onceFlag,
[] {
m_instance.reset(new CSingleton);
});
return *m_instance.get();
}