单例模式-析构函数的深入理解

singleton单例模式单件模式

保证一个类中仅有一个实例,并且提供一个访问他的全局访问点
a. 懒汉式：使用的时候才创建，多线程访问的时候线程不安全(双检锁)
b. 饿汉式：类文件加载的时候已经创建好了对象，如果对象一直没有使用，则类对象浪费空间

#注意
1. 构造函数私有化，
2. 私有的静态类指针指向类的实例（类外声明）
3. 共有的静态方法去获取一个访问实例的访问点
4. 析构函数需要定义一个嵌套类的析构函数去释放单例
5. 绝对不要在单例的析构函数中释放单例(coredump)!!!!!!!!! 详情看下面有问题的单例代码

#include <iostream>
using namespace std;

class A
{
    private:
        static A *m_p;

    public:
        static A *getSingleTon()
        {
            if(NULL == m_p)
            {
                m_p = new A();

            }

            return m_p;

        }


/*        ~A()
        {
            if(NULL != m_p)
            {
                cout << "xxx" << endl;

                delete m_p; // 递归调用析构
                m_p = NULL;

                cout << "yyy" << endl; // 永远也不会执行

            }

        }
*/
};

A* A::m_p = NULL;


int main()
{
    A *p = A::getSingleTon();
    delete p;

    return 0;

}

所以单例析构函数：定义一个静态的嵌套类对象的析构函数去析构单例对象，简单思想看如下代码：

#include<iostream>
using namespace std;

//嵌套类去析构单例类对象
class A
{
    public:
    ~A()
    {
        cout << "deconstructor A" << endl;
    }
    class B
    {
        public:
        ~B()      //嵌套类成员的析构函数去析构单例函数的对象
        {
            cout << "调用嵌套 deconstructor B" << endl; 
        }
    };

    private:
    static  B b;
    static int a;
};
int  A::a = 10;
A::B A::b;        //嵌套静态类成语,必须类外声明

int main()
{
    return 0;
}

需要清楚一下几点：

1、单例中的 new 的对象需要delete释放。

2、delete释放对象的时候才会调用对象的析构函数。

3、如果在析构函数里调用delete，那么程序结束时，根本进不去析构函数，怎么会delete。

4、如果程序结束能自动析构，那么就会造成一个析构的循坏，所以new对应于delete。

/////////////////////////////////////////////////////////////////////////////////////////////////

A.懒汉式单例模式

//懒汉式 （创建的时候采取new实例）以时间换取空间，线程不安全
class singleton_L
{
    public:
        static singleton_L* getinstance()
        {
            if(instance == NULL)
            {
                instance = new singleton_L();
            }
            return instance;
        }
        
        //实际上在析构函数中析构对象是一种错误的做法,会调用,切是一个死递归,正确做法是创建一个嵌套的析构类
        /*~singleton_L()
        {
            if(instance != NULL)
            {
                delete instance;
                instance = NULL;
            }
        
            cout << "~singleton_L()" << endl;
        }*/
    private:
        class Garbo //设置为私有防止外界访问
        {
            public:
                ~Garbo()//实际去析构new的单例对象
                {
                    if(singleton_L::instance != NULL)
                    {
                        cout << "delete singleton" << endl;
                        delete singleton_L::instance;
                        singleton_L::instance = NULL;
                    }
                }
        };
    
    private:
        singleton_L(){}
        static singleton_L*  instance;  //单例唯一实力
        static Garbo garbo;             //静态私有的嵌套类对象,防止被外界访问
};

singleton_L*       singleton_L::instance = NULL;
singleton_L::Garbo singleton_L::garbo;  //静态类对象类外声

B懒汉式，线程安全方法

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

    private:
        class GGGarbo
        {
            public:
                ~GGGarbo()
                {
                    if(singleton_L_Lock::instance != NULL)
                    {
                        delete singleton_L_Lock::instance;
                        singleton_L_Lock::instance = NULL;
                    }
                }
        };
    public:
        static pthread_mutex_t mutex;
    private:
        singleton_L_Lock()
        {
            pthread_mutex_init(&mutex, NULL);
        }
    private:
        static singleton_L_Lock*  instance;
        static GGGarbo gggarbo;
};

singleton_L_Lock* singleton_L_Lock::instance = NULL;
pthread_mutex_t   singleton_L_Lock::mutex;  
singleton_L_Lock::GGGarbo singleton_L_Lock::gggarbo;

c.饿汉式，不牵扯线程安不安全，以空间换时间

//饿汉式（在定义实例的时候就去new对象）以空间换时间
class singleton_E
{
    public:
        static singleton_E* getinstance()
        {
            return instance;
        }

       // ~singleton_E(){}
        class GGarbo
        {
            public:
                ~GGarbo()
                {
                    if(singleton_E::instance != NULL)
                    {
                        cout << "delete singleton_E" << endl;
                        delete singleton_E::instance;
                        singleton_E::instance = NULL;
                    }
                }
        };
    private:
        singleton_E(){}
        static singleton_E* instance;
        static GGarbo ggarbo;
};

singleton_E*        singleton_E::instance = new singleton_E();
singleton_E::GGarbo singleton_E::ggarbo;

以上就是我对单例模式的一些理解心得，如有不对的地方多多指教，哈哈哈。

单例模式-析构函数的深入理解

猜你喜欢