C++设计模式(一)单例模式_单例用不用释放-优快云博客

C++单例模式也称为单件模式、单子模式。使用单例模式，保证一个类仅有一个实例，并提供一个访问它的全局访问点，该实例被所有程序模块共享。有很多地方需要这样的功能模块，如系统的日志输出等。

单例模式有许多种实现方法，

a. 懒汉式：使用的时候才创建，多线程访问的时候线程不安全(双检锁)
b. 饿汉式：类文件加载的时候已经创建好了对象，如果对象一直没有使用，则类对象浪费空间

特点与选择：

如果要进行线程同步，访问量比较大，或者可能访问的线程比较多时，采用饿汉实现，可以实现更好的性能。这是以空间换时间。
在访问量较小时，采用懒汉实现。这是以时间换空间。

在C++中，甚至可以直接用一个全局变量做到这一点，但这样的代码显得很不优雅。定义一个单例类，使用类的私有静态指针变量指向类的唯一实例，并用一个公有静态方法获取该实例。如下面的类定义：

//懒汉式 （创建的时候采取new实例）以时间换取空间，线程不安全
class CSingleton
{  
	// 其它成员  
public:  
	static CSingleton * GetInstance()  
	{  
		if (m_pInstance == NULL)  
			m_pInstance = new CSingleton();
		return m_pInstance;  
	}  
	//在析构函数中析构对象是一种错误的做法,会调用,是一个死递归,正确做法是创建一个嵌套的析构类
	/*~CSingleton()
	{
		if( m_pInstance != NULL)
		{
			delete  m_pInstance;
			 m_pInstance = NULL;
		}
	
		cout << "~CSingleton()" << endl;
	}
    */
private:  
	CSingleton(){};  
	static CSingleton * m_pInstance;
};

C++单例模式类CSingleton有以下特征：

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

大多时候，这样的实现都不会出现问题，但是设计class应当像设计type一样，需要考虑初始化和销毁。再来看m_pInstance指向的空间什么时候释放呢？更严重的问题是，这个实例的析构操作什么时候执行？
如果在类的析构行为中有必须的操作，比如关闭文件，释放外部资源，那么上面所示的代码无法实现这个要求。我们需要一种方法，正常地删除该实例。

为什么不在析构函数中释放m_pInstance呢？

1、单例中的 new 的对象需要delete释放。
2、delete释放对象的时候才会调用对象的析构函数。
3、如果在析构函数里调用delete，那么程序结束时，根本进不去析构函数，怎么会delete。
4、如果程序结束能自动析构，那么就会造成一个析构的循坏，所以new对应于delete。

可以在程序结束时调用GetInstance并对返回的指针调用delete操作。这样做可以实现功能，但是不仅很丑陋，而且容易出错。因为这样的附加代码很容易被忘记，而且也很难保证在delete之后，没有代码再调用GetInstance函数。

一个妥善的方法是让这个类自己知道在合适的时候把自己删除。或者说把删除自己的操作挂在系统中的某个合适的点上，使其在恰当的时候自动被执行。

我们知道，程序在结束的时候，系统会自动析构所有的全局变量。事实上，系统也会析构所有的类的静态成员变量，就像这些静态成员也是全局变量一样。利用这个特征，我们可以在单例类中定义一个这样的静态成员变量，而它的唯一工作就是在析构函数中删除单例类的实例。如下面的代码中Garbage类：

//懒汉式 （创建的时候采取new实例）以时间换取空间，线程不安全
class CSingleton
{  
    // 其它成员  
public:  
    static CSingleton * GetInstance()
	{  
		if (m_pInstance == NULL)  
			m_pInstance = new CSingleton();
		return m_pInstance;  
	} 
    void print() { cout << "address: " << this << '\t' << "uniq_val:" << uniq_val++ << endl; }

private:  

    CSingleton(){};  
    static CSingleton * m_pInstance;  

    class Garbage // 它的唯一工作就是在析构函数中删除 CSingleton的实例  
    {  
    public:  
		~Garbage ()  
		{  
			if (CSingleton::m_pInstance)
            {
				delete CSingleton::m_pInstance; 
                CSingleton::m_pInstance = NULL;
            }
		}
	};  

	static Garbage garbage; // 定义一个静态成员，在程序结束时，系统会调用它的析构函数  
};
CSingleton*       CSingleton::m_pInstance= NULL;
CSingleton::Garbage CSingleton::garbo;//静态类对象类外声明

类Garbage被定义为CSingleton的私有内嵌类，以防该类被在其它地方滥用。
在程序运行结束时，系统会调用CSingleton的静态成员Garbage的析构函数，该析构函数会删除单例的唯一实例。
使用这种方法释放C++单例模式对象有以下特征：

在单例类内部定义专有的嵌套类。
在单例类内定义私有的专门用于释放的静态成员。
利用程序在结束时析构全局变量的特性，选择最终的释放时机。
使用C++单例模式的代码不需要任何操作，不必关心对象的释放。

但这是一个完美的实现吗？不！该方法是线程不安全的，考虑两个线程同时首次调用GetInstance方法且同时检测到p是NULL值，则两个线程会同时构造一个实例给p，这是严重的错误！为了保证线程安全，可以用锁。

//懒汉式 线程安全式（双检锁）
/*
  所谓双重检查加锁机制，指的是：并不是每次进入getInstance方法都需要同步，而是先不
同步，进入方法过后，先检查实例是否存在，如果不存在才进入下面的同步块，这是第一重
检查。进入同步块过后，再次检查实例是否存在，如果不存在，就在同步的情况下创建一个
实例，这是第二重检查。这样一来，就只需要同步一次了，从而减少了多次在同步情况下进
行判断所浪费的时间。
*/
class CSingleton
{  
    // 其它成员  
public:  
    static CSingleton * GetInstance()
	{
		if( m_pInstance == NULL)
		{
			pthread_mutex_lock(&mutex);  //加锁
			if( m_pInstance == NULL)
				 m_pInstance = new CSingleton();
			pthread_mutex_unlock(&mutex);
		}
		return  m_pInstance;
	}

	static pthread_mutex_t mutex;
private:  
	CSingleton()
	{
		pthread_mutex_init(&mutex, NULL);
	} 
    static CSingleton * m_pInstance;  

    class Garbage // 它的唯一工作就是在析构函数中删除 CSingleton的实例  
    {  
    public:  
		~Garbage ()  
		{  
			if (CSingleton::m_pInstance)
			{ 
				delete CSingleton::m_pInstance;
				CSingleton::m_pInstance = NULL;
			} 
		}
	};  

	static Garbage garbage; // 定义一个静态成员，在程序结束时，系统会调用它的析构函数  
};

CSingleton* CSingleton:: m_pInstance= NULL;
pthread_mutex_t   CSingleton::mutex;  
CSingleton::Garbage CSingleton::garbage;

再来看看饿汉的实现方式,即无论是否调用该类的实例，在程序开始时就会产生一个该类的实例，并在以后仅返回此实例。

由静态初始化实例保证其线程安全性，WHY？因为静态实例初始化在程序开始时进入主函数之前就由主线程以单线程方式完成了初始化，不必担心多线程问题。

故在性能需求较高时，应使用这种模式，避免频繁的锁争夺。

//饿汉式（在定义实例的时候就去new对象）以空间换时间
class CSingleton
{  
    // 其它成员  
public:  
    static CSingleton * GetInstance()
	{
		return  m_pInstance;
	}

private:  

    class Garbage // 它的唯一工作就是在析构函数中删除 CSingleton的实例  
    {  
    public:  
		~Garbage ()  
		{  
			if (CSingleton::m_pInstance)
			{ 
				delete CSingleton::m_pInstance;
				CSingleton::m_pInstance = NULL;
			} 
		}
	};  
	CSingleton(){}; 
    static CSingleton * m_pInstance;
	static Garbage garbage; // 定义一个静态成员，在程序结束时，系统会调用它的析构函数  
};

CSingleton* CSingleton::m_pInstance = new CSingleton(); 
CSingleton::Garbage CSingleton::garbage;