【C++】单例模式中的析构函数

最近写完项目，正是一波总结的时候。项目中用到了大量的单例模式，然而本以为写的轻车熟路的代码，结果却问题重重，单例模式如何析构？单例模式中如何保证线程安全？如何加锁？锁要封装成单例类嘛？这个单例类构造出1个对象会不会有问题？阻塞住会不会后面上锁的功能无法正常使用？还是锁不用单例模式封装？构造锁的对象时加static？？......

不测试不知道，一测试一堆问题需要解决，好，从头开始看。

--------------------------------------------------------------------------------------

如何写单例模式？

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

随便找一个项目中的单例模式的代码片段：

（看了很多博客才知道，原来这个叫：双检锁保证线程安全的懒汉式单例模式）

所谓双重检查加锁机制，指的是：并不是每次进入getInstance方法都需要同步，而是先不
同步，进入方法过后，先检查实例是否存在，如果不存在才进入下面的同步块，这是第一重
检查。进入同步块过后，再次检查实例是否存在，如果不存在，就在同步的情况下创建一个
实例，这是第二重检查。这样一来，就只需要同步一次了，从而减少了多次在同步情况下进
行判断所浪费的时间。

单例模式的特点总结起来就是：

1.构造函数放在私有 ：这样外界就不可以访问构造函数，保证单个对象创建

2.私有的静态类指针指向类的唯一实例，在类外声明：static成员存放于内存中，静态数据成员被当作是类的成员，在类中只有一份；静态数据成员定义时要分配空间，所以不能在类声明中定义。应该在类外定义

3.共有的静态方法去获得访问实例：静态方法为类的全部服务。

class Server
{
public:
	static Server* getServer(string ip,unsigned short port)
	{
		if(NULL == _instance)
		{
            
            pthread_mutex_lock(&mutex);
			if(NULL == _instance)
			{
				_instance = new Server(ip,port);
			}
            pthread_mutex_unlock(&mutex);
		}
		return _instance;
	}

public：
    static pthread_mutex_t mutex;
private:
	Server(string ip,unsigned short port)
	{
	     pthread_mutex_init(&mutex,NULL);
	}
	static Server* _instance;
};
Server* Server::_instance = NULL;

pthread_mutex_t Server::mutex;

 

写完后，想起一句话：一个new对应一个delete。

于是我想当然的在函数中加了析构函数：如下：

	~Server()
	{
		delete _instance; 
	}

程序运行时，崩溃，出现了core dump 

那么我们分析一下，什么是析构函数，其作用是什么？

1、析构函数名是在类名前加以符号“~”。 
2、析构函数没有参数、返回类型和修饰符。 
3、一个类中至多有一个析构函数，如果程序员没有定义析构函数，那么系统会自动地加入一个析构函数。 
4、不能显式地调用析构函数，而是由系统自动调用。（曾经我写了个程序exit函数，竟然主动调用析构，咳咳，真是。。。往事不堪回首。。。）

5.先构造的后析构，够构造的先析构.....（从大二念到毕业的一句话...）

析构函数什么时候被调用?

析构函数在下边3种情况时被调用：
1.对象生命周期结束，被销毁时；
2.delete指向对象的指针时，或delete指向对象的基类类型指针and其基类虚构函数是虚函数时；
3.对象i是对象o的成员，o的析构函数被调用时，对象i的析构函数也被调用

那么，就找到问题了

~Server()
    {
        delete _instance; 
    }

析构函数中delete _instance;_instance为类的唯一对象的指针，

delete指向对象的指针时会调用析构函数，那么这句代码会调用~Server（），~Server中又要delete对象的指针，则陷入无限递归，程序崩溃。

 

解决方法：

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

class Garbo //设置为私有防止外界访问
        {
            public:
                ~Garbo()//实际去析构new的单例对象
                {
                    if(ServerL::_instance != NULL)
                    {
                        deleteServerL::_instance;
                        ServerL::_instance = NULL;
                    }
                }
        };

 static Garbo garbo; //静态私有的嵌套类对象,防止被外界访问

最终这个单例模式的Server类为：

class Server
{
public:
	static Server* getServer(string ip,unsigned short port)
	{
		if(NULL == _instance)
		{     
            pthread_mutex_lock(&mutex);
			if(NULL == _instance)
			{
				_instance = new Server(ip,port);
			}
            pthread_mutex_unlock(&mutex);
		}
		return _instance;
	}

public：
    static pthread_mutex_t mutex;
private：
    class Garbo //设置为私有防止外界访问
    {
     public:
          ~Garbo()//实际去析构new的单例对象
          {
              if(ServerL::_instance != NULL)
               {
                   deleteServerL::_instance;
                   ServerL::_instance = NULL;
                }
          }
     };
     static Garbo garbo;
private:
	Server(string ip,unsigned short port)
	{
	     pthread_mutex_init(&mutex,NULL);
	}
	static Server* _instance;
};
Server* Server::_instance = NULL;

pthread_mutex_t Server::mutex;