C++ Singleton模式
C++ Singleton
Lazy Singleton
C++11的一个Lazy Singleton（懒汉）版本：
class Singleton { public: Singleton(const Singleton&) = delete; Singleton& operator=(const Singleton&) = delete; static Singleton* getInstance() { if (!instance) { instance = new Singleton(); } return instance; } private: Singleton() {} static Singleton* instance; }; Singleton* Singleton::instance = 0;
Lazy Singleton存在2个问题：
- 内存泄露（instance如何释放？）；
- 非线程安全；
内存释放
线程安全
能在多线程环境下实现单例模式，我们首先想到的是利用加锁来正确的保护我们的shared data，如下
class Singleton { public: Singleton(const Singleton&) = delete; Singleton& operator=(const Singleton&) = delete; static Singleton* getInstance() { if (!instance) { std::lock_guard<std::mutex> lockGuard(lock); instance = new Singleton(); } return instance; } private: Singleton() {} static Singleton* instance; static std::mutex lock; }; Singleton* Singleton::instance = 0; std::mutex Singleton::lock;
看起来不错哦，应该没有问题了吧？但如果有多个线程同时通过 if(!instance) 的条件检查（因为他们并行运行），虽然我们的lock_guard会帮助我们同步所有的线程，让我们并行线程变成串行的一个一个去new，那不还是一样的吗？同样会出现很多实例。
这里可以使用双检测锁模式（DCL: Double-Checked Locking Pattern）：
static Singleton* getInstance() { if (!instance) { std::lock_guard<std::mutex> lockGuard(lock); if (!instance) { instance = new Singleton(); } } return instance; }
注意，加锁仅在第一次初始化（new）过程中，而在后面获取该实例的时候并不会再遇到，也就没有必要再使用lock。
双检测锁很好地解决了这个问题，它通过加锁前检测是否已经初始化，避免了每次获取实例时都要首先获取锁资源。
加入DCL后，其实还是有问题的，new运算符并不是原子操作，它分为三步：1、申请内存；2、调用构造函数；3、返回指针；
由于编译器的优化以及运行时优化等等原因，最终的执行顺序可能是 1-2-3 ，也可能是 1-3-2。如果是后者，则在 3 执行完毕、2 未执行之前，被线程二抢占了，这时 instance 已经是非 null 了（但却没有初始化），所以线程二会直接返回 instance，然后使用，然后顺理成章地报错。
我们可以再改为原子操作：
class Singleton { public: Singleton(const Singleton&) = delete; Singleton& operator=(const Singleton&) = delete; static Singleton* getInstance() { if (!instance) { std::lock_guard<std::mutex> lockGuard(lock); if (!instance) { instance.store(new Singleton()); } } return instance.load(); } private: Singleton() {} static atomic<Singleton*> instance; static std::mutex lock; }; atomic<Singleton*> Singleton::instance(NULL); std::mutex Singleton::lock;
局部static变量
local static 对象（函数内）
对于local static 对象，其初始化发生在控制流第一次执行到该对象的初始化语句时。多个线程的控制流可能同时到达其初始化语句。
在C++11之前，在多线程环境下local static对象的初始化并不是线程安全的。具体表现就是：如果一个线程正在执行local static对象的初始化语句但还没有完成初始化，此时若其它线程也执行到该语句，那么这个线程会认为自己是第一次执行该语句并进入该local static对象的构造函数中。这会造成这个local static对象的重复构造，进而产生内存泄露问题。所以，local static对象在多线程环境下的重复构造问题是需要解决的。
而C++11则在语言规范中解决了这个问题。C++11规定，在一个线程开始local static 对象的初始化后到完成初始化前，其他线程执行到这个local static对象的初始化语句就会等待，直到该local static 对象初始化完成。
class Singleton { public: Singleton(const Singleton&) = delete; Singleton& operator=(const Singleton&) = delete; static Singleton& getInstance() { static Singleton instance; return instance; } private: Singleton() {} };
这样，只有当第一次访问getInstance()方法时才创建实例。这种方法也被称为Meyers' Singleton。C++0x之后该实现是线程安全的，C++0x之前仍需加锁。
Eager Singleton（饿汉版）
non-local static对象（函数外）
C++规定，non-local static 对象的初始化发生在main函数执行之前，也即main函数之前的单线程启动阶段，所以不存在线程安全问题。但C++没有规定多个non-local static 对象的初始化顺序，尤其是来自多个编译单元的non-local static对象，他们的初始化顺序是随机的。
instance 在程序运行时（先于main函数）被立即执行初始化
class Singleton { public: Singleton(const Singleton&) = delete; Singleton& operator=(const Singleton&) = delete; static Singleton& getInstance() { return instance; } private: static Singleton instance; Singleton() {} }; Singleton Singleton::instance;
由于在main函数之前初始化，所以没有线程安全的问题。但是潜在问题在于no-local static对象（函数外的static对象）在不同编译单元中的初始化顺序是未定义的。
也即，static Singleton instance;和static Singleton& getInstance()二者的初始化顺序不确定，如果在初始化完成之前调用 getInstance() 方法会返回一个未定义的实例。
Java 版本
看一个java的实现
public class Singleton { private volatile static Singleton singleton = null ; private Singleton() { } public static Singleton getInstance() { if (singleton== null ) { synchronized (Singleton. class ) { if (singleton== null ) { singleton= new Singleton(); } } } return singleton; } }
这里没有用原子操作，而是使用 volatile， 它有两个功用：
1）这个变量不会在多个线程中存在复本，直接从内存读取。
2）这个关键字会禁止指令重排序优化。也就是说，在 volatile 变量的赋值操作后面会有一个内存屏障（生成的汇编代码上），读操作不会被重排序到内存屏障之前。
同样，Java的static版本
public class Singleton { private volatile static Singleton singleton = new Singleton(); private Singleton() { } public static Singleton getInstance() { return singleton; } }
当这个类被加载的时候，new Singleton() 这句话就会被执行，就算是getInstance()没有被调用，类也被初始化了。
参考：
