c++ 单例模式研究

一篇博文：C++ 单例模式的几种实现研究 中

看到的几段代码

懒汉模式

 class Singleton
 {
 public:
     static Singleton* GetInstance()
     {
         if (m_pInstance == NULL )
         {
             Lock(); // 加锁
             if (m_pInstance == NULL )
             {
                 m_pInstance = new Singleton ();
             }
             UnLock(); // 解锁
         }
         return m_pInstance;
     }

     // 实现一个内嵌垃圾回收类
     class CGarbo
     {
     public:
         ~CGarbo()
         {
             if(Singleton::m_pInstance)
                 delete Singleton::m_pInstance;
         }
     };

     static CGarbo Garbo; // 定义一个静态成员变量，程序结束时，系统会自动调用它的析构函数从而释放单例对象

 private:
     Singleton(){};
     Singleton(Singleton const&);
     Singleton& operator=(Singleton const&); 

     static Singleton* m_pInstance;
 };

 Singleton* Singleton::m_pInstance = NULL;
 Singleton::CGarbo Garbo;

c++11以上

 class Singleton
 {
 public:
     static Singleton* GetInstance()
     {
         Lock(); // not needed after C++0x
         static Singleton instance;
         UnLock(); // not needed after C++0x 

         return &instance;
     }

 private:
     Singleton() {};
     Singleton(const Singleton &);
     Singleton & operator = (const Singleton &);
 };

饿汉模式

 class Singleton
 {
 public:
     static Singleton* GetInstance()
     {
         static Singleton instance;
         return &instance;
     }

 protected:
     // 辅助代理类
     struct Object_Creator
     {
         Object_Creator()
         {
             Singleton::GetInstance();
         }
     };
     static Object_Creator _object_creator;

     Singleton() {}
     ~Singleton() {}
 };

 Singleton::Object_Creator Singleton::_object_creator;

解决跨编译单元的初始化顺序，即A生成依赖B，但是先生成A还生成B不能确定

如果没有这种需求基础的饿汉就可以

关于使用懒汉还是饿汉模式，博主的理解：

如果这个单例对象构造十分耗时或者占用很多资源，比如加载插件啊， 初始化网络连接啊，读取文件啊等等，而有可能该对象程序运行时不会用到，那么也要在程序一开始就进行初始化，也是一种资源浪费吧。 所以这种情况懒汉模式（延迟加载）更好。

如果这个单例对象在多线程高并发环境下频繁使用，性能要求较高，那么显然使用饿汉模式来避免资源竞争，提高响应速度更好。

从中我们可以看到的是性能需求，我们用c++的需求应该就是从性能出发。所以当对对象性能要求不高时，懒汉模式推荐；性能要求高时，饿汉模式推荐。