【设计模式】单例模式常用形式：饿汉式、懒汉式、多线程下的单例模式

单例模式

概念：

单例模式(Singleton)也叫单态模式，是设计模式中最为简单的一种模式，甚至有些模式大师都不称其为模式，称其为一种实现技巧，因为设计模式讲究对象之间的关系的抽象，而单例模式只有自己一个对象，也因此有些设计大师并把把其称为设计模式之一。

实现思路：

一个类能返回对象一个引用(永远是同一个)和一个获得该实例的方法（必须是静态方法，通常使用getInstance这个名称）；当我们调用这个方法时，如果类持有的引用不为空就返回这个引用，如果类保持的引用为空就创建该类的实例并将实例的引用赋予该类保持的引用；同时我们还将该类的构造函数定义为私有方法，这样其他处的代码就无法通过调用该类的构造函数来实例化该类的对象，只有通过该类提供的静态方法来得到该类的唯一实例。

适用场景：

单例模式只允许创建一个对象，因此节省内存，加快对象访问速度，因此对象需要被公用的场合适合使用，如多个模块使用同一个数据源连接对象等等。如：
1.需要频繁实例化然后销毁的对象。
2.创建对象时耗时过多或者耗资源过多，但又经常用到的对象。
3.有状态的工具类对象。
4.频繁访问数据库或文件的对象。

以下都是单例模式的经典使用场景：
1.资源共享的情况下，避免由于资源操作时导致的性能或损耗等。如上述中的日志文件，应用配置。
2.控制资源的情况下，方便资源之间的互相通信。如线程池等。

常见的单例模式共三种，分别是饿汉式、懒汉式、多线程下的单例模式。

饿汉式

饿汉式如何理解？我们可以想象成这个类非常“饿”，恨不得立刻就创建好这个单例。因此饿汉式的实现思路是，在定义类的时候就创建好单例。该方法很好地实现了空间换时间的目的。

代码示例：

#inlcude<iostream>
using namespace std;

class SingleTon{
private:
    SingleTon(){};//构造函数私有化
    static SingleTon* Instance;//创建单例，类外赋值
public:
    static SingleTon* GetInstance(){//获取单例的静态方法
        return Instance;
    }
};
SingleTon* SingleTon::Instance=new SingleTon();

int main(void){
    SingleTon* s1=SingleTon::GetInstance();
    return 0;
}

懒汉式

饿汉式如何理解？我们可以想象成这个类非常“懒”，等不到调用GetInstance函数就不创建实例。因此饿汉式的实现思路是，在调用GetInstance函数的时候才创建好单例。该方法很好地实现了时间换空间的目的。

代码示例：

#inlcude<iostream>
using namespace std;

class SingleTon{
private:
    SingleTon(){};//构造函数私有化
    static SingleTon* Instance;//创建单例，类外赋值
public:
    static SingleTon* GetInstance(){//获取单例的静态方法
        if(Instance==nullptr){//初次调用的前提下
            Instance=new SingleTon;
        }
        return Instance;
    }
};
SingleTon* SingleTon::Instance=nullptr;//初始为nullptr

int main(void){
    SingleTon* s2=SingleTon::GetInstance();
    return 0;
}

多线程下的单例模式

为了保证多线程下，依然可以安全地使用单例模式，通过设置锁，来实现线程安全。

以懒汉式为例，代码示例：

#inlcude<iostream>
#include<pthread>
using namespace std;

class SingleTon{
private:
    SingleTon(){};//构造函数私有化
    static SingleTon* Instance;//创建单例，类外赋值
public:
    static SingleTon* GetInstance(){//获取单例的静态方法
        pthread_mutex_lock(&mutex);//锁住，其他线程无法使用单例
        if(Instance==nullptr){//初次调用的前提下
            Instance=new SingleTon;
        }
        pthread_mutex_unlock(&mutex);//解锁
        return Instance;
    }
};
SingleTon* SingleTon::Instance=nullptr;//初始为nullptr
pthread_mutex_t SingleTon::mutex;

int main(void){
    SingleTon* s3=SingleTon::GetInstance();
    return 0;

析构的实现

细心的小伙伴肯定会发现这样的一个问题：s1、s2、s3指向的空间什么时候释放？该实例的析构函数又是什么时候执行呢？

如果类的析构函数中要有必要的行为规范，如：关闭文件，释放外部资源，那么上面的代码显然是无法满足要求的。这时候，我们需要使用一种方法，正常的删除实例，并对返回的指针调用delete操作。这样做可以实现功能，但不仅很丑陋，而且容易出错。因为这样的附加代码很容易被忘记，而且也很难保证在delete之后，没有代码再调用GetInstance函数。

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

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

代码示例：

#inlcude<iostream>
using namespace std;

class SingleTon{
private:
    SingleTon(){};//构造函数私有化
    static SingleTon* Instance;//创建单例，类外赋值
    class deleteClass
	{
		public:
		~deleteClass()
		{
			if(SingleTon::Instance)
			{
				delete SingleTon::Instance;
				SingleTon::Instance = nullptr;
			}
		}
	};
	static deleteClass deleteObj;
public:
    static SingleTon* GetInstance(){//获取单例的静态方法
        pthread_mutex_lock(&mutex);//锁住，其他线程无法使用单例
        if(Instance==nullptr){//初次调用的前提下
            Instance=new SingleTon;
        }
        pthread_mutex_unlock(&mutex);//解锁
        return Instance;
    }
};
SingleTon* SingleTon::Instance=nullptr;//初始为nullptr
pthread_mutex_t SingleTon::mutex;
SingleTon::deleteClass SingleTon::deleteObj;

int main(void){
    SingleTon* s4=SingleTon::GetInstance();
    return 0;