创建型模式－－单例模式

单例模式：

　　　　保证一个类仅有一个实例，并提供一个访问它的全局访问点。

特点：

　　　　1、私有的构造函数

　　　　2、私有的复制构造函数

　　　　3、私有的赋值操作符

问题：

　　　　1、线程安全

　　　　2、数据的清理

代码：

　　一般有三种写法：

　　方法一：一个不是线程安全的代码，而且也没有解决内存释放的问题：

class Singleton
{
public:
    static Singleton* getInstance()
    {

        /**< 假如有两个线程，第一个线程运行时，判断pInstance是否为空，因为此时pInstance
         *   ==NULL,那么线程将会进入到if结构体内，假设，就在要执行new Singleton这个操作
         *   时，时间片结束，那么此时pInstance还是为NULL，此时另一个线程运行，当它进行判
         *   断时发现pInstance为空，所以会创建一次，当它执行完后，第一个线程执行，又会产
         *   生一个新的实例，那么将会产生两个，所以此时是线程不安全的。要想保证安全，必须
         *   if前面加锁
         */
        if(pInstance == NULL)
        {
            pInstance = new Singleton;
        }
        return pInstance;
    };
private:
    Singleton(){};
    Singleton(const Singleton &);
    Singleton& operator=(const Singleton &);

    static Singleton *pInstance;
};

Singleton* Singleton::pInstance = NULL;

方法二 ：只解决了内存释放的问题：

　　

class Singleton
{
public:
    static Singleton* getInstance()
    {
        /**< 其实这里加上互斥操作，就可以实现，即是线程安全，又释放了内存 */
        if(pInstance == NULL)
        {
            pInstance = new Singleton;
        }
        return pInstance;
    };

    class Garbage
    {
    public:
        ~Garbage()
        {
            if(Singleton::pInstance)
            {
                delete pInstance;
            }
        };
    };
private:
    Singleton(){};
    Singleton(const Singleton &);
    Singleton& operator=(const Singleton &);

    static Singleton *pInstance;
    static Garbage m_Garbage;       /**<  当这个静态变量释放时，会自动去释放Singleton的资源*/
};

方法三：即解决了线程安全的问题，也解决了内存释放的问题

class Singleton
{
public:
    static Singleton* getInstance()
    {
        /**< 此函数会在全局区中分配空间，而且在整个程序退出时，清理数据
        ＊   ，所以就不会存在线程不安全的情况
        */
        static Singleton single;
        return &single;
    };
private:
    Singleton(){};
    Singleton(const Singleton &);
    Singleton& operator=(const Singleton &);
};