单例模式

1.概述

　　单例模式用来保证系统中一个类只有一个实例且该实例易于外界访问，从而方便对实例个数的控制并节约系统资源。

　　我的理解是：单例模式的实质就是私有化构造函数（保证只有一个实例）、析构函数（保证只有单例类能删除自己，防止其他类删除单例类造成悬浮引用）、拷贝构造函数（禁止类拷贝）、重载=操作符（禁止类赋值）。

 

2.常用的场景

　　单例模式常常与工厂模式结合使用，因为工厂只需要创建产品实例就可以了，在多线程的环境下也不会造成任何的冲突，因此只需要一个工厂实例就可以了。

 

3.全局变量和单例模式的比较

　　采用全局或者静态变量，会影响封装性，难以保证别的代码不会对全局变量造成影响。

　　全局变量可以提供单例模式实现的全局访问这个功能，但它不能保证应用程序只有一个实例。

 

4.代码及分析

1）懒汉式单例模式

　　懒汉式是典型的时间换空间。就是每次获取实例都会进行判断，看是否需要创建实例，浪费判断的时间。

class Singleton {
public:
    static Singleton* getInstance();
    //析构的时候释放资源~
    ~Singleton() {
        if( (_instance != NULL) 
            delete _instance;
    }
protected:
    Singleton();
private:
    static Singleton* _instance;
}
 
Singleton *Singleton::_instance = NULL;
Singleton* Singleton::getInstance() {
    if( _instance == NULL) {
        _instance = new Singleton();
    }
    return _instance;
}

　　在单线程环境可以通过以上方式实现单例模式，但是在多线程的环境下，若两个线程同时运行到if (instance == NULL)这一句，导致可能会产生两个实例。于是就要在代码中加锁。

class Lock
{
private:       
    mutex mtex;
public:
    Lock(mutex m) : mtex(m)
    {
        mtex.Lock();
    }
    ~Lock()
    {
        mtex.Unlock();
    }
};

class Singleton {
public:
    static Singleton* getInstance();
    //析构的时候释放资源~
    ~Singleton() {
        if( (_instance != NULL) 
            delete _instance;
    }
protected:
    Singleton();
private:
    static Singleton* _instance;<br>    static mutex m;
}
 
Singleton *Singleton::_instance = NULL;
Singleton* Singleton::getInstance() {    
    //check 之前进行临界区加锁操作    
    Lock lock(m);
    if( _instance == NULL) {
        _instance = new Singleton();
    }
    return _instance;
}

　　如上，如果已经有一个线程进入访问，其他线程必须等待，这样就能够保证多线程情况下实例的唯一。但互斥的同步会导致性能的降低，因为即使_instance已经不为空了，每次还是需要加锁，这样操作花费就比较多，性能必定比较差。

　　解决的办法是在加锁前先判断实例是否为空，即加 “双重检验加锁”。

class Lock
{
private:       
    mutex mtex;
public:
    Lock(mutex m) : mtex(m)
    {
        mtex.Lock();
    }
    ~Lock()
    {
        mtex.Unlock();
    }
};
class Singleton {
public:
    static Singleton* getInstance();
    //析构的时候释放资源~
    ~Singleton() {
        if( (_instance != NULL) 
            delete _instance;
    }
protected:
    Singleton();
private:
    static Singleton* _instance;
    static mutex m;
}
 
Singleton *Singleton::_instance = NULL;
Singleton* Singleton::getInstance() {
    //check 之前进行临界区加锁操作
    //双重检验加锁
    if(_instance == NULL ) {
        Lock lock(m);
        if( _instance == NULL) {
            _instance = new Singleton();
        }
    }
    return _instance;
}

　　这样只需要在第一次调用的时候加锁，可大大提高效率。

2）饿汉式单例模式

　　饿汉式是典型的空间换时间，当类装载的时候就会创建类的实例，不管你用不用，先创建出来，然后每次调用的时候，就不需要再判断，节省了运行时间。。

class Singleton {
public:
    static Singleton* getInstance();
    //析构的时候释放资源~
    ~Singleton() {
            delete _instance;
    }
protected:
    Singleton();
private:
    static Singleton* _instance;
}
 
Singleton *Singleton::_instance = new Singleton();
Singleton* Singleton::getInstance() {
    return _instance;
}

　　这样的话同样会导致问题：无论这个类是否被使用，都会创建一个instance对象。如果这个创建过程很耗时，比如需要连接10000次数据库，并且这个类还并不一定会被使用，那么这个创建过程就是无用的。

　　解决的办法是添加静态内部类。

　　以下，参考http://blog.csdn.net/hackbuteer1/article/details/7460019

3）懒汉式单例模式--静态内部类方式

class CSingleton
{
private:
    CSingleton(){}
    static CSingleton *m_pInstance;
    class CGarbo   //它的唯一工作就是在析构函数中删除CSingleton的实例
    {
    public:
        ~CGarbo()
        {
            if(CSingleton::m_pInstance)
            delete CSingleton::m_pInstance;
        }
    };
    static CGarbo Garbo;  
    //定义一个静态成员变量，程序结束时，系统会自动调用它的析构函数
public:
    static CSingleton * GetInstance()
    {
        if(m_pInstance == NULL)  //判断是否第一次调用
        m_pInstance = new CSingleton();
        return m_pInstance;
    }
};
    

　　

　　类CGarbo被定义为CSingleton的私有内嵌类，以防该类被在其他地方滥用。

　　程序运行结束时，系统会调用CSingleton的静态成员Garbo的析构函数，该析构函数会删除单例的唯一实例。

4）懒汉式单例模式--静态局部变量方式

　　但是添加一个类的静态对象，总是让人不太满意，所以有人用如下方法来重新实现单例和解决它相应的问题，代码如下：

class CSingleton
{
private:
    CSingleton()   //构造函数是私有的
    {
    }
public:
    static CSingleton & GetInstance()
    {
        static CSingleton instance;   //局部静态变量
        return instance;
    }
};

　　使用局部静态变量，完全实现了单例的特性，而且代码量更少，也不用担心单例销毁的问题。
　　但使用此种方法也会出现问题，当Singleton singleton = Singleton :: GetInstance();时，就出现了一个类拷贝的问题，违背了单例的特性。产生这个问题原因在于：编译器会为类生成一个默认的构造函数，来支持类的拷贝。

　　要禁止类拷贝和类赋值，禁止程序员用这种方式来使用单例，可以将拷贝构造函数和重载=操作符声明为私有函数。见5）扩展后的单例模式。

5）扩展后的单例模式

　　考虑到线程安全、异常安全，可以做以下扩展

class Lock
{
private:       
    CCriticalSection m_cs;
public:
    Lock(CCriticalSection  cs) : m_cs(cs)
    {
        m_cs.Lock();
    }
    ~Lock()
    {
        m_cs.Unlock();
    }
};

class Singleton
{
private:
    Singleton();
    Singleton(const Singleton &);                // 私有拷贝函数
    Singleton& operator = (const Singleton &);   // 私有重载=操作符函数

public:
    static Singleton *Instantialize();
    static Singleton *pInstance;
    static CCriticalSection cs;
};

Singleton* Singleton::pInstance = 0;

Singleton* Singleton::Instantialize()
{
    if(pInstance == NULL)
    {   //double check
        Lock lock(cs);          
        //用lock实现线程安全，用资源管理类，实现异常安全
        //使用资源管理类，在抛出异常的时候，资源管理类对象会被析构，析构总是发生的无论是因为异常抛出还是语句块结束。
        if(pInstance == NULL)
        {
            pInstance = new Singleton();
        }
    }
    return pInstance;
}