C++ 单例模式的几种实现研究

都是从网上学得，整理下本身的理解。 

 

单例模式有两种实现模式：

1）懒汉模式： 就是说当你第一次使用时才建立一个惟一的实例对象，从而实现延迟加载的效果。

2）饿汉模式： 就是说无论你未来用不用，程序启动时就建立一个惟一的实例对象。

 

因此，从实现手法上看，  懒汉模式是在第一次使用单例对象时才完成初始化工做。由于此时可能存在多线程竞态环境，如不加锁限制会致使重复构造或构造不彻底问题。

饿汉模式则是利用外部变量，在进入程序入口函数以前就完成单例对象的初始化工做，此时是单线程因此不会存在多线程的竞态环境，故而无需加锁。 

 

如下是典型的几种实现

1、 懒汉模式，标准的 ”双检锁“  + ”自动回收“ 实现

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;

 

 

2、静态局部变量的懒汉模式 ，而不是new在堆上建立对象，避免本身回收资源。

这里仍然要注意的是局部变量初始化的线程安全性问题，在C++0X之后，要求编译器保证静态变量初始化的线程安全性，能够不加锁。但C++ 0X之前，仍须要加锁。

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 &);
};

在懒汉模式里，若是大量并发线程获取单例对象，在进行频繁加锁解锁操做时，必然致使效率低下。

 

3、饿汉模式，基础版本

由于程序一开始就完成了单例对象的初始化，因此后续再也不须要考虑多线程安全性问题，就能够避免懒汉模式里频繁加锁解锁带来的开销。

class Singleton
{
public:

    static Singleton* GetInstance()
    {
        return &m_instance;
    }

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

    static Singleton m_instance;
};

Singleton Singleton::m_instance;  // 在程序入口以前就完成单例对象的初始化

虽然这种实如今必定程度下能良好工做，可是在某些状况下会带来问题 --- 就是在C++中 ”非局部静态对象“ 的 ”初始化“ 顺序 的 ”不肯定性“， 参见Effective c++ 条款47。

考虑： 若是有两个这样的单例类，将分别生成单例对象A, 单例对象B. 它们分别定义在不一样的编译单元（cpp中）， 而A的初始化依赖于B 【 即A的构造函数中要调用B::GetInstance() ，而此时B::m_instance 可能还未初始化，显然调用结果就是非法的 】， 因此说只有B在A以前完成初始化程序才能正确运行，而这种跨编译单元的初始化顺序编译器是没法保证的。 

 

4、饿汉模式，加强版本（boost实现）

在前面的方案中：饿汉模式中，使用到了类静态成员变量，可是遇到了初始化顺序的问题； 懒汉模式中，使用到了静态局部变量，可是存在着线程安全等问题。

boost 的实现方式是：单例对象做为静态局部变量，而后增长一个辅助类，并声明一个该辅助类的类静态成员变量，在该辅助类的构造函数中，初始化单例对象。如下为代码

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; 

首先，代理类这个外部变量初始化时，在其构造函数内部调用 Singleton::GetInstance();从而间接完成单例对象的初始化，这就经过该代理类实现了饿汉模式的特性。

其次，仍然考虑第三种模式的缺陷。 当A的初始化依赖于B， 【 即A的构造函数中要调用B::GetInstance() ，而此时B::m_instance 可能还未初始化，显然调用结果就是非法的 】 如今就变为【在A的构造函数中要调用B::GetInstance() ，若是B还没有初始化，就会引起B的初始化】，因此在不一样编译单元内全局变量的初始化顺序不定的问题就随之解决。  

 

 

 

最后，关于使用懒汉仍是饿汉模式，个人理解：

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

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