我们在实现单例模式时，考虑的第一点是对象的创建和访问只有一个共同的入口，所以必须满足以下两个条件：

• 访问入口是与对象无关的
• 构造函数必须是隐藏的，不能被外部通过直接调用产生新对象

所以我们的实现中有两个关键点：

• 静态方法getInstance做为访问入口
• 将构造函数设为private

根据这两个原则，我们先有了第一版简单实现：

V1.0

//Singleton.h
class Singleton{
public:
    static Singleton* getInstance();
private:
    Singleton(){};
    static Singleton _instance;
};

//Singleton.cpp
Singleton Singleton::_instace;
Singleton* Singleton::getInstance(){
    return &_instance;
}

这里貌似是把Singleton实现的很好，完全符合上述提到的两点。但是“一切代码都没有完美的”，我们总能找出缺点和问题的。比如这里，_instance对象是声明为static的，即在程序运行之初就初始化在静态存储区域了。但是万一我的整个程序中根本就没用到这个对象呢？这时候这就是一种浪费了。就算是在程序中用到了，我也希望是在我第一次使用它时，它才被创建并初始化的。在《Effective C++》的条款04中，Scott Meyers更是指出了这种实现方式的严重的错误之处：
假设有两个Singleton类，其中一个以另一个为参数进行初始化，即存在一个 static SingletonA SingletonA::_instance 和另一个以此为参数初始化的 static SingletonB SingletonB::_instance(SingletonA::_instance) ，这两个non-local static对象位于两个不同的编译单元内，而C++对于“定义于不同的编译单元内的non-local static对象”的初始化相对次序并无明确定义。所以就会出现SingletonB::_instance对象在SingletonA::_instance对象之前初始化，那就意味着此时SingletonA::_instance处于“半随机”状态，这会导致不可测知的程序行为。
所以我们有了下一个版本：

V1.1

//Singleton.h
class Singleton{
public:
    static Singleton* getInstance();
private:
    Singleton(){};
};

//Singleton.cpp
Singleton* Singleton::getInstance(){
    static Singleton _instance;
    return &_instance;
}

这也是Scott Meyers在《Effective C++》中提出的方法——用local static替换non-local static， 这样不仅解决了初始化次序问题，同时实现了lazy initialization。当然，“一切代码都没有完美的”，考虑到多线程系统中与初始化相关的race conditions：当多个线程同时第一次调用getInstance()，此时会多次产生静态对象。Scott Meyers提出的解决方法是，在程序的单线程启动阶段，手工的调用getInstance()方法。这并不是一个优雅的写法，我们希望只在真正需要对象的时候才去调用getInstance()。那么就需要在getInstance方法里加锁保护。
所以我们又有了下一个版本：

V1.2

//Singleton.h
#include <mutex>
class Singleton{
public:
    static Singleton* getInstance();
private:
    Singleton(){};
    static std::mutex _mutex;
};

//Singleton.cpp
std::mutex Singleton::_mutex;
Singleton* Singleton::getInstance(){
    std::lock_guard<std::mutex> lck(_mutex);
    static Singleton _instance;
    return &_instance;
}

这里又引入了一个新的non-local static变量Singleton::_mutex，是不是感觉是在拆东墙补西墙？幸好的是这里无需面对初始化次序的问题，Singleton::_mutex的初始化不依赖其他静态对象，而lazy initialization在这里也不是什么大问题，也就顾不上了。
虽然通过加锁互斥解决了静态变量初始化的线程安全问题，但是考虑另一种调用情形：当_instance已经在之前的调用中构造出来了，然后此时再次调用getInstance()方法时，仍然需要对锁进行操作，这样显然是不合理的。应该在判断_instance已经存在并初始化之后就直接返回其指针，不做锁操作。那么就需要再引入一个non-local static变量来表示是否已初始化过，OMG！那么干脆就用一个指针来指代_instance对象吧，这样也就可以用指针是否为NULL来判断对象是否已创建。
下面是我们的判断对象是否已创建的指针版本：

V2.0

//Singleton.h
#include <mutex>
class Singleton{
public:
    static Singleton* getInstance();
private:
    Singleton(){};
    static std::mutex _mutex;
    static Singleton* _instance;
};

//Singleton.cpp
std::mutex Singleton::_mutex;
Singleton* Singleton::_instance = NULL;
Singleton* Singleton::getInstance(){
    if (NULL == _instance){
        std::lock_guard<std::mutex> lck(_mutex);
        _instance = new Singleton();
    }
    return _instance;
}

这样好像是把问题都解决了。慢着，当两个线程同时第一次调用getInstance时，都会判断 NULL == _instance 条件成立，于是都要执行构造对象操作，由于锁的存在，同时只会有一个线程构造对象，但是当前一个线程构造完毕之后就退了锁，于是第二个线程进去了，继续重新构造对象。看来只有在加锁之后对 NULL == _instance 条件再进行一次判断了。
加锁前后两次判断的版本：

V2.1

//Singleton.h
#include <mutex>
class Singleton{
public:
    static Singleton* getInstance();
private:
    Singleton(){};
    static std::mutex _mutex;
    static Singleton* _instance;
};

//Singleton.cpp
std::mutex Singleton::_mutex;
Singleton* Singleton::_instance = NULL;
Singleton* Singleton::getInstance(){
    if (NULL == _instance){
        std::lock_guard<std::mutex> lck(_mutex);
        if (NULL == _instance){
            _instance = new Singleton();
        }
    }
    return _instance;
}

这种方式称之为 Double-Checked Locking 技术。那么，这个方式还有没有改进的空间呢？当然，“一切代码都没有完美的”，试想我们的系统中有很多类是Singleton模式时，难道我们要把这套方法对每个类都复制一遍么？为了避免代码重复，我们怎么去实现呢？继承？抑或者类模板？

路漫漫其修远兮，吾将上下而求索