//懒汉模式：lazy load  只有用了才加载  复杂场景下也可以使用 namespace LAZY {     class Lock     {     public:         Lock(mutex& mux) :_mux(mux){             //_mux.lock();         }         ~Lock(){             //_mux.unlock();         }         //防拷贝     protected:         Lock(const Lock& mx);         Lock& operator=(const Lock& mx);     private:         mutex& _mux;     };     class Singleton     {     public:         //判断是否为空，如果为空则创建，不为空就直接返回         static Singleton* GetInstance()         {             //加锁线程安全，如果中间返回了会造成死锁  所以自己写了一个             //mu.lock();             lock_guard<mutex> lock(mu);             // 双检查             if (_ints == NULL)             {                 Lock lock(mu);                 if (_ints == NULL)                 {                                Singleton* tmp = new Singleton;                     //内存栅栏  栅栏之后和之前的语句不能被打乱 防止编译器对程序进行优化                     MemoryBarrier();                     _ints = tmp;                 }             }             //mu.unlock();             return _ints;         }         //销毁单例模式         static void DelInstance()         {             lock_guard<mutex> lock(mu);             if (_ints)             {                 cout << "test if delete" << endl;                 delete _ints;                 _ints = NULL;             }         }         //防拷贝，只声明不实现         Singleton(const Singleton&);         Singleton& operator=(const Singleton&);         void Print()         {             cout << "Singleton:" << _a << endl;         }     private:         //将构造函数声明为私有         Singleton() :_a(0)         {}         int _a;         static mutex mu;         static Singleton* _ints;     };     Singleton* Singleton::_ints = NULL;     mutex Singleton::mu;     void test()     {         Singleton::GetInstance()->Print();         //如果在此之后还有人创建单例怎么办？？所以最好不要手动释放         //Singleton::DelInstance();         atexit(Singleton::DelInstance);     } } //饿汉模式：程序运行就创建  简洁，适用性会受到限制   namespace HUNGRY {     class Singleton     {     public:         static Singleton& GetInstance()         {             static Singleton inst;//进来第一次创建  后面进来不再创建，直接返回             return inst;         }         void Print()         {             cout << "Singleton:" << _a << endl;         }     protected:         Singleton() :_a(0)         {}         Singleton(const Singleton&);         Singleton& operator=(const Singleton&);         int _a;     };     void test1()     {         Singleton::GetInstance().Print();     } } int main() {     //HUNGRY::test1();     LAZY::test();     system("pause");     return 0; }