饿汉式单例模式：还没有获取实例对象，实例对象就已经产生了
class Singleton { public: static Singleton* getInstance() { return &instance; } private: static Singleton instance; Singleton() { } Singleton(const Singleton&) = delete; Singleton& operator=(const Singleton&) = delete; }; //静态成员变量类外初始化 Singleton Singleton::instance; int main() { Singleton *p1 = Singleton::getInstance(); Singleton *p2 = Singleton::getInstance(); Singleton *p3 = Singleton::getInstance(); //如果没有私有化拷贝构造，这里会发生拷贝 //Singleton p4 = *p1; cout << "p1: " << p1 << " p2: " << p2 << " p3: " << p3 /*<< " p4: " << &p4*/ << endl; return 0; }
饿汉式单例模式一定是线程安全的，因为静态成员变量在程序启动后就完成了初始化，不会有线程安全问题。但存在一些缺点，如果程序中始终没有用到该单例，并且在构造函数中又做了大量的事情，比如打开文件等等，这时无疑会影响效率。
懒汉式单例模式：唯一的实例对象，直到第一次获取它的时候，才产生
class Singleton { public: static Singleton* getInstance() { if (instance == nullptr) { instance = new Singleton(); } return instance; } private: static Singleton *instance; Singleton() { } Singleton(const Singleton&) = delete; Singleton& operator=(const Singleton&) = delete; }; Singleton* Singleton::instance = nullptr; int main() { Singleton *p1 = Singleton::getInstance(); Singleton *p2 = Singleton::getInstance(); Singleton *p3 = Singleton::getInstance(); cout << "p1: " << p1 << " p2: " << p2 << " p3: " << p3 << endl; return 0; }
懒汉式解决了用到时再初始化的问题，但却不是线程安全的。
多线程环境下，构造对象时可能会出现问题：
static Singleton* getInstance() { if (instance == nullptr) { /* 开辟内存 构造对象 给instance赋值 */ instance = new Singleton(); } return instance; }
比如构造对象时会经历三步，第一个线程进来发现instance为空，进行开辟内存，但还没给instance赋值，这时instance还为空，这时第二个线程也可以进入构造，函数不可重入。同时，现代计算机为了加快运行速度，构造对象和给instance赋值的操作完全可能顺序相反，这时如果第二个线程发现instance不为空，直接返回，也会发生错误，因为这时完成了赋值却还没构造。
一种解决方法是加锁：
mutex mtx; class Singleton { public: static Singleton* getInstance() { lock_guard<std::mutex> guard(mtx); if (instance == nullptr) { /* 开辟内存 构造对象 给instance赋值 */ instance = new Singleton(); } return instance; } ... }
但是这种情况对于单线程又不友好，每次都要加锁，锁的粒度太大。现在将锁放在if里面
mutex mtx; class Singleton { public: static Singleton* getInstance() { if (instance == nullptr) { lock_guard<std::mutex> guard(mtx); /* 开辟内存 构造对象 给instance赋值 */ instance = new Singleton(); } return instance; } ... }
这时同样存在问题，第一个线程进入if，加锁，new对象，这时第二个线程判断instance为空，进入等待锁，第一个线程new完后，第二个线程拿到锁，同样会new对象。
所以这时就要进行双重检测：
static Singleton* getInstance() { if (instance == nullptr) { lock_guard<std::mutex> guard(mtx); if (instance == nullptr) { /* 开辟内存 构造对象 给instance赋值 */ instance = new Singleton(); } } return instance; }
这时便完成了线程安全的单例模式。
private: static Singleton *volatile instance; Singleton() { } Singleton(const Singleton&) = delete; Singleton& operator=(const Singleton&) = delete; }; Singleton*volatile Singleton::instance = nullptr;
一种更为简洁的写法是：
class Singleton { public: static Singleton* getInstance() { //函数静态局部变量的初始化，在汇编指令上已经自动添加线程互斥指令了 static Singleton instance; return &instance; } private: Singleton() { } Singleton(const Singleton&) = delete; Singleton& operator=(const Singleton&) = delete; };
