C++设计模式（十七）—单例模式

单例模式

保证一个类仅有一个实例，并提供一个访问它的全局访问点

本文讲解单例模式框架，代码使用C++语言描述，代码存在的不足或问题有望各位指出。

（1）懒汉单例模式框架

#include <iostream>
using namespace std;

class Singleton
{
public:
    static Singleton* Instance();
protected:
    Singleton()
    {
        cout << "singleton "<<endl;

    }
    ~Singleton()
    {
        delete _instance;
    }
private:
    class Garbo
    {
    public:
        ~Garbo()
        {
            if (Singleton::_instance)
            {
                cout << "Garbo dtor" << endl;
                delete Singleton::_instance;
            }
        }
    };
    static Garbo garbo;
    static Singleton* _instance;

};
Singleton::Garbo Singleton::garbo;
Singleton* Singleton::_instance =nullptr;
Singleton* Singleton::Instance()
{
    if (_instance == nullptr)
    {
    _instance = new Singleton();
    }
    return _instance;
}
int main()
{
    Singleton* sgn_1 = Singleton::Instance();
    Singleton* sgn_2 = Singleton::Instance();
    if(sgn_1 == sgn_2)
        cout<< "两个对象是相同的实例"<<endl;
    return 0;
}

单例模式内存释放：

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

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

1、在单例类内部定义专有的嵌套类;

2、在单例类内定义私有的专门用于释放的静态成员;

3、利用程序在结束时析构全局变量的特性，选择最终的释放时机;

4、使用单例的代码不需要任何操作，不必关心对象的释放。

（2）多线程单例模式

//多线程单例模式

#include <iostream>
#include <pthread.h>
using namespace std;
pthread_mutex_t mu;

class Singleton
{
public:
    static Singleton* Instance();
protected:
    Singleton()
    {
        cout << "singleton "<<endl;

    }
private:
    static Singleton* _instance;
    class Garbo
    {
    public:
        ~Garbo()
        {
            if (Singleton::_instance)
            {
                cout << "Garbo dtor" << endl;
                delete Singleton::_instance;
            }
        }
    };
    static Garbo garbo;
};
Singleton::Garbo Singleton::garbo;
Singleton* Singleton::_instance =nullptr;
Singleton* Singleton::Instance()
{
    if (_instance == nullptr)
    {
        pthread_mutex_lock(&mu);
        if(_instance == nullptr)
        {
            _instance = new Singleton();
        }
        pthread_mutex_unlock(&mu);
    }
    return _instance;
}
int main()
{
    pthread_mutex_init(&mu, NULL);
    Singleton* sgn_1 = Singleton::Instance();
    Singleton* sgn_2 = Singleton::Instance();
    if(sgn_1 == sgn_2)
        cout<< "两个对象是相同的实例"<<endl;
    pthread_mutex_destroy(&mu);
    return 0;
}

（3）饿汉单例模式

//单例模式框架

#include <iostream>
using namespace std;

class Singleton
{
public:
    static Singleton* Instance();
protected:
    Singleton()
    {
        cout << "singleton "<<endl;

    }
private:
    class Garbo
    {
    public:
        ~Garbo()
        {
            if (Singleton::_instance)
            {
                cout << "Garbo dtor" << endl;
                delete Singleton::_instance;
            }
        }
    };
    static Garbo garbo;
    static const Singleton* _instance;

};
Singleton::Garbo Singleton::garbo;
Singleton* Singleton::Instance()
{
    return const_cast<Singleton*> (_instance);
}
const Singleton* Singleton::_instance = new Singleton();
int main()
{
    Singleton* sgn_1 = Singleton::Instance();
    Singleton* sgn_2 = Singleton::Instance();
    if(sgn_1 == sgn_2)
        cout<< "两个对象是相同的实例"<<endl;
    return 0;
}

这种静态初始化的方式是在自己被加载时就将自己实例化，所以被形象地称为饿汉式单例类，原先的单例模式处理方式是要在第一次被引用时，才会将自己实例化，所以就被称为懒汉式单例类。

单例模式使用

1、通常我们可以让一个局部变量使得一个对象被访问，但它不能防止你实例化多个对象。一个最好的办法就是，让类自身负责保存它的唯一实例。这个类可以保证没有其他实例可以被创建，并且它可以提供一个访问实例的方法。

2、单例模式因为Singleton类封装它的唯一实例，这样它可以严格的控制客户怎样访问它以及何时访问它。简单地来说就是对唯一实例的受控访问。