c++ 单例模式的浅谈

面对单例模式适用的情况，可能会优先考虑使用全局或者静态变量的方式，

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

《设计模式》一书中给出了一种很不错的实现，定义一个单例类，使用类的私有静态指针变量指向类的唯一实例，并用一个公有的静态方法获取该实例。

//Singleton.h

#ifndef _SINGLETON_H_
#define _SINGLETON_H_


#include <iostream>
using namespace std;


class Singleton
{
    public:
        static Singleton* Instance();   //公有的静态方法获取该实例
    protected:
        Singleton();  //构造函数是保护的
    private:
        static Singleton* _instance;   //私有静态指针变量指向类的唯一实例
};


#endif //~_SINGLETON_H_

//Singleton.cpp


#include "Singleton.h"
#include <iostream>


using namespace std;


Singleton* Singleton::_instance = NULL;


Singleton::Singleton()
{
    cout<<"Singleton...."<<endl;
}


Singleton* Singleton::Instance()
{
    if (_instance == NULL)    //判断是否第一次调用  
    {   
        _instance = new Singleton();
    }   
    return _instance;
}

//main.cpp


#include "Singleton.h"
#include <iostream>
using namespace std;


int main(int argc,char* argv[])
{
    Singleton* sgn = Singleton::Instance();
    return 0;
}

//============================================

在单线程中

Singleton* Singleton::Instance()
{
    if (_instance == NULL)    //判断是否第一次调用  
    {   
        _instance = new Singleton();
    }   
    return _instance;
}

这样就可以了，保证只取得了一个实例。但是在多线程的环境下却不行了，因为很可能两个线程同时运行到if (instance == NULL)这一句，导致可能会产生两个实例。于是就要在代码中加锁。 

Singleton* Singleton::Instance()
{
    lock();
    if (_instance == NULL)
    {
       _instance = new Singleton();
    }
    unlock();


    return _instance;
} 但这样写的话，会稍稍映像性能，因为每次判断是否为空都需要被锁定，如果有很多线程的话，就爱会造成大量线程的阻塞。于是大神们又想出了双重锁定。 

Singleton* Singleton::Instance()
{
    if (_instance == NULL)
    {
lock();
    if (_instance == NULL)
    {
        _instance = new Singleton();
    }
    unlock();
    }


    return _instance;
} 这样只够极低的几率下，通过越过了if (instance == NULL)的线程才会有进入锁定临界区的可能性，这种几率还是比较低的，不会阻塞太多的线程，但为了防止一个线程进入临界区创建实例，另外的线程也进去临界区创建实例，又加上了一道防御if (instance == NULL)，这样就确保不会重复创建了。 

单例类Singleton有以下特征：
 它有一个指向唯一实例的静态指针_Instance，并且是私有的；
 它有一个公有的函数，可以获取这个唯一的实例，并且在需要的时候创建该实例；
 它的构造函数是私有的，这样就不能从别处创建该类的实例。

大多数时候，这样的实现都不会出现问题。

有经验的读者可能会问，_Instance指向的空间什么时候释放呢？

更严重的问题是，该实例的析构函数什么时候执行？

 如果在类的析构行为中有必须的操作，比如关闭文件，释放外部资源，那么上面的代码无法实现这个要求。

我们需要一种方法，正常的删除该实例。可以在程序结束时调用Instance()，并对返回的指针掉用delete操作。

这样做可以实现功能，但不仅很丑陋，而且容易出错。

因为这样的附加代码很容易被忘记，而且也很难保证在delete之后，没有代码再调用GetInstance函数。

 一个妥善的方法是让这个类自己知道在合适的时候把自己删除，或者说把删除自己的操作挂在操作系统中的某个合适的点上，使其在恰当的时候被自动执行。
 我们知道，程序在结束的时候，系统会自动析构所有的全局变量。

事实上，系统也会析构所有的类的静态成员变量，就像这些静态成员也是全局变量一样。

利用这个特征，我们可以在单例类中定义一个这样的静态成员变量，而它的唯一工作就是在析构函数中删除单例类的实例。如下面的代码中的

class Singleton
{
    public:
        static Singleton* Instance();   //公有的静态方法获取该实例
    protected:
        Singleton();  //构造函数是保护的
    private:
        static Singleton* _instance;   //私有静态指针变量指向类的唯一实例

        class CGarbo   //它的唯一工作就是在析构函数中删除Singleton的实例  
        {  
   public:  

        ~CGarbo()  {  

            if(Singleton::_Instance)  

                delete Singleton::_Instance;  

      }  

  };  
static CGarbo Garbo;  //定义一个静态成员变量，程序结束时，系统会自动调用它的析构函数
};

类CGarbo被定义为Singleton的私有内嵌类，以防该类被在其他地方滥用。
 程序运行结束时，系统会调用Singleton的静态成员Garbo的析构函数，该析构函数会删除单例的唯一实例。
 使用这种方法释放单例对象有以下特征：
 在单例类内部定义专有的嵌套类；
 在单例类内定义私有的专门用于释放的静态成员；
 利用程序在结束时析构全局变量的特性，选择最终的释放时机；
 使用单例的代码不需要任何操作，不必关心对象的释放。