C++实现单例模式

第一次写关于技术的文章，选择了一个单例模式这样的例子作为开头。用自己的理解去实现，希望能够表达清楚。

懒汉式

class Singleton{    private:        Singleton(){}        static Singleton* instance;    public:        static Singleton* getInstance()        {            if(NULL == instance)            {                instance = new Singleton();            }            return instance;        }};

//静态成员变量必须在实现文件中进行定义，而不仅仅是在头文件中声明

Singleton* Singleton::instance = NULL;

这个代码简单，但是会存在内存泄漏的问题，new出来的对象始终没有释放，下面是它的一种改进。

class Singleton{    private:        Singleton() {}        static Singleton* m_pInstance;        //嵌套类        class CGrabo        {            public:            ~CGrabo()            {                if(Singleton::m_pInstance)                {                    delete Singleton::m_pInstance;                    Singleton::m_pInstance = NULL;                }            }        };        static CGrabo Grabo;    public:        static Singleton* getInstance()        {            if(NULL == m_pInstance)            {                m_pInstance = new Singleton();            }            return m_pInstance;        }};

说明：在程序运行结束的时候，静态成员变量Grabo的析构函数会被调用，该析构函数会删除单例中的唯一实例。其特点是在单例类的内部定义专有的内部类，并且定义该类的一个私有静态成员，利用静态变量的特性，选择最终的释放时机。

饿汉式

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

饿汉模式实现简单并且是线程安全的，在类创建的同事就已经创建好一个静态的对象供系统使用。

懒汉模式在多线程中会出现线程安全的问题，因为在懒汉模式中单例实例有两种状态，分别是初始化和未初始化。假设单例实例还没有初始化，有两个线程同事调用getInstance方法，这是执行m_pInstance==NULL肯定为真，然后两个线程都初始化一个实例，最后得到的指针并不是指向同一个地方，不满足单例的定义了。在多线程环境下，要对其进行修改。

多线程下的单例模式

——————————— 懒汉模式

class Singleton{    private:        static Singleton* m_pInstance;        Singleton(){}    //嵌套类    class CGrabo    {        public:        ~CGrabo()        {            if(Singleton::m_pInstance)            {                delete Singleton::m_pInstance;                Singleton::m_pInstance = NULL;            }        }    };    static CGrabo Grabo;    public:        static Singleton* getInstance();};

在实现类实现

Singleton* Singleton::getInstance(){    if(NULL == m_pInstance)    {        Lock();//通过同步类来实现，如临界区，事件，互斥，信号量等        if(NULL == m_pInstance)        {            m_pInstance = new Singleton();        }        UnLock();    }    return m_pInstance;}

这里为什么需要两次判断m_pInstance？？这是为了防止一个线程进入临界区创建实例，另外的线程也进入临界区创建实例，所以加上第二个判断if(NULL==m_pInstance），确保不会重复创建。

如果是这样写是否也可以???

Singleton* Singleton::getInstance(){    lock();    if(NULL == m_pInstance)    {        m_pInstance = new Singleton();    }    unlock();    return m_pInstance;}

这样写的话，会稍微影响性能，因为每次判断是否为空都需要被锁定，如果有很多线程的话，就会造成大量线程阻塞。

既然如此，也会有人想能不能把同步锁放入到判断空里面，这样就不会每次都锁了，像这样：

Singleton* Singleton::getInstance(){    if(NULL == m_pInstance)    {        lock();        m_pInstance = new Singleton();        unlock();    }    return m_pInstance;}

这样就又回到了饿汉模式的非线程安全上去了。

这是总结的一些东西，或许并不是总结得很好，也会有很多自己没有想到的东西，或者还有更加巧妙的方法来改进，这里暂时就不再深究了。