单例模式（Singleton）很简单，从名字也很容易知道解决的是唯一对象创建问题，很多时候，如果因为一个对象只需要存在一份，正常对象创建方式有种杀鸡用牛刀的感觉。同时，也不能假设用户素质足够高，至少我们要保证从语法上，多个对象存在是不合理的，我们所要做的，就是约束使用者的行为。
意图：
保证一个类仅有一个实例，并提供一个全局访问点。
在c++中为了限定对象的创建，我们需要把构造函数设置为私有，保证无法从外界构造，同时需要一个静态变量指针来保存唯一对象，最后至少还需要一个函数来获得这个唯一对象。
class Singleton{ private: Singleton()=default; static Singleton* _instance; public: static Singleton* getInstance(); }; Singleton* Singleton::m_instance=nullptr; //c++11 nullptr Singleton* Singleton::getInstance() { if (_instance == nullptr) { //多线程触发点 _instance = new Singleton(); } return _instance; }
李建忠老师的设计模式这里让我大开眼界，送上笔记一枚：
-------------------------------------------------------------note------------------------
这种实现方式在单线程下，已经很好了，但是再多线程下，存在安全隐患。
在多线程情况下，如果多个线程同时执行到 if 判断那里，当第一个线程进入判断，然后第二个线程也进入判断，依次类推，可能有多个线程进入判断，这样就造成多个实例被new出来，而最终只有一个能被获得，剩下的将成为内存泄露的一分子。所以，我们很自然的想到用线程锁来解决，假设有这样一个线程锁，我们可以这样实现：
Singleton* Singleton::getInstance() { Lock lock; if (_instance == nullptr) { _instance = new Singleton(); }
lock.relase(); return _instance; }
但是又考虑到，if判断，只有有限的一次可能执行到，剩下大超级大的一部分是不可能进入判断的，也就是说，仅仅为了有限的o（1）次，我们就每一次创建一个锁，然后释放，如果次数足够多，并发量足够大，效率有很大的影响。很自然是不允许的，对于很多需要效率的场景，需要有更好的做法，所以有了曾经风靡一时的双重锁解法。
Singleton* Singleton::getInstance() { if(_instance==nullptr) { Lock lock; if (_instance == nullptr) { _instance = new Singleton(); } lock.realse(); } return _instance; }
保证了在足够多次的情况下，都不会获得锁，即使有幸获得锁，我们在进行判断，防止漏网之鱼，其实这代码从高级语言层面上看已经很完美了，然而，这里面竟然存在安全隐患。
叫做内存reorder隐患。 参考资料：链接
简单的说，_instance = new Singleton() 我们这一句的理想顺序是 创建空间->构造对象->赋值给指针。但是底层基于效率考虑，可能会编译成这样一种执行顺序，就是 创建空间->赋值给指针->构造对象。这样就造成如果刚好某个线程执行到了，赋值给指针，这一步，然后切换到另一个线程它判断，发现指针不是null，于是它就直接返回对象，注意，这个时候它返回了一个还未构造属性的对象。这就是问题所在。
最后，附上c++11新标准的解决方案，直接复制代码过来。
std::atomic<Singleton*> Singleton::_instance; std::mutex Singleton::m_mutex; Singleton* Singleton::getInstance() { Singleton* tmp = _instance.load(std::memory_order_relaxed); std::atomic_thread_fence(std::memory_order_acquire);//获取内存fence if (tmp == nullptr) { std::lock_guard<std::mutex> lock(m_mutex); tmp = _instance.load(std::memory_order_relaxed); if (tmp == nullptr) { tmp = new Singleton; std::atomic_thread_fence(std::memory_order_release);//释放内存fence m_instance.store(tmp, std::memory_order_relaxed); } } return tmp; }
--------------------end----------------------------
下面写一些见解，纯思考：
----------------------------------------------------------语法思考-------------------------------------------------------------------------------------
c++类里面,static 可以定义成指针，也能定义成普通的成员。
抛出疑问：
class Singleton { Singleton()=default; static Singleton _instance; public: static Singleton getInstance(); }; Singleton Singleton::_instance = Singleton(); Singleton Singleton::getInstance() { return _instance; }
这种方式好像也能解决多线程问题，我不知道存不存在安全隐患，暂且保留，后续补充。
另外，我们对比一下一个类里面如果这三种定义：
class A { static A a; //合理 static A *b; //合理 A *c; //合理 A d;//不合理 }
很正常的语法，之前也做过思考，我们只要知道第四个为什么不合理，一切都明了了。在类实例被创建的时候，如果是第四种形式，你可以想象，这样的定义是需要默认初始化，或者如果你给它一个类。但是他本身是一个A实例，这个A实例也存在这样的一个A实例，于是A实例里面有个A1实例，A1实例里面有个A2实例，何时是终结。就好像山上有个庙，庙里有个和尚，和尚说：“山上有个庙。。。”。
如果是指针，那么可以默认初始化为null，这样null就不存在A实例，就不会进入和尚的庙。至于静态变量，如果你理解它的内存空间，其实不管是任何实例，都是同一个A实例，是唯一的同一个。基于此，我做过一个耐人寻味的测试：
class A { static A a; public: int b; } A A::a = A();
int main() { A test = A(); test.a.a.a.a.a.b = 1; cout << test.a.b<<endl; test.a.a.a.a.a.a.a.a.a.a.a.b = 2; cout << test.a.b<<endl; return 0; }
能猜到结果吗。
------------------------------------------------------------end--------------------------------------------------------------------------------------