设计模式——单例模式

设计模式：

设计模式代表了最佳实践，是软件开发过程中面临一般问题的解决方案。 设计模式是一套被反复使用、经过分类、代码设计总结的经验。

单例模式

单例模式也叫单件模式。Singleton是一个非常常用的设计模式，几乎所有稍微大一些的程序都会使用到它，所以构建一个线程安全并且 高效的Singleton很重要。

1. 单例类保证全局只有一个唯一实例对象。

2. 单例类提供获取这个唯一实例的接口。

由于要求只生成一个实例，因此我们必须把构造函数的访问权限标记为protected或private，限制只能在类内创建对象.

单例类要提供一个访问唯一实例的接口函数（全局访问点），就需要在类中定义一个static函数，返回在类内部唯一构造的实例。

（这样还可以确保直接用类名就能访问到该唯一实例，不必用到实例化出的对象名去调用）

---

 两个概念：

 懒汉模式 （lazy loading ）：第一次调用GetInstance才创建实例对象，比较复杂
 饿汉模式：  程序一运行，就创建实例对象、简洁高效 ，但有些场景下不适用 

方法一：不考虑线程安全，只适用于单线程环境的单例类

定义一个静态的实例，在需要的时候创建该实例 （懒汉模式）

class Singleton
{
public:
	//获取唯一对象实例的接口函数
	static Singleton* GetInstance()
	{
		if (_instance == NULL)
		{
			_instance = new Singleton();
		}
		return _instance;
	}
	static void DelInstance()
	{
		if (_instance != NULL)
		{
			delete _instance;
			_instance = NULL;
		}
	}
	void Print()
	{
		cout << _data << endl;
	}
protected:
	//构造函数标记为protected或private，限制只能在类内创建对象
	Singleton()
		:_data(5)
	{}

	//防拷贝
	Singleton(const Singleton&);
	Singleton operator=(const Singleton&);
private:		
	//指向实例的指针定义为静态私有，这样定义静态成员函数获取对象实例
	static Singleton* _instance;	  // 单实例对象
	int _data;  //单实例对象中的数据
};
// 静态成员在类外初始化
Singleton* Singleton::_instance = NULL;

　　这种方法是最简单、最普遍的方法。只有在_instance为NULL的时候才会创建一个实例以避免重复创建。同时我们把构造函数定义为私有函数，这样就能确保只创建一个实例。

但是上述的代码在单线程的时候工作正常，在多线程的情况下就有问题了。

　　设想如果两个线程同时运行到判断_instance是否为NULL的 if 语句那里，并且_instance之前并未创建时，这两个线程各自就都会创建一实例，这是就无法满足单例模式的要求了。

---

 方法二：能在多线程环境下工作，但是效率不高

为了保障在多线程环境下只得到一个实例，需要加一把互斥锁。把上述代码稍作修改，即：

ps: 下面部分的加锁使用了C++11库的互斥锁

class Singleton
{
public:
	//获取唯一对象实例的接口函数
	static Singleton* GetInstance()
	{
		//lock();        //C++中没有直接的lock()
		//RAII
		//lock lk;
		_sMtx.lock();   //C++11
		if (_instance == NULL)
		{
			_instance = new Singleton();
		}
		//unlock();
		_sMtx.unlock();
		return _instance;
	}
	static void DelInstance()
	{
		if (_instance != NULL)
		{
			delete _instance;
			_instance = NULL;
		}
	}
	void Print()
	{
		cout << _data << endl;
	}
protected:
	//构造函数标记为protected或private，限制只能在类内创建对象
	Singleton()
		:_data(5)
	{}

	//防拷贝
	Singleton(const Singleton&);
	Singleton operator=(const Singleton&);

private:
	//指向实例的指针定义为静态私有，这样定义静态成员函数获取对象实例
	static Singleton* _instance;	  // 单实例对象
	int _data;								  // 单实例对象中的数据
	static mutex _sMtx;	              // 互斥锁
};
// 静态成员在类外初始化
Singleton* Singleton::_instance = NULL;
mutex Singleton::_sMtx;

　　设想有两个线程同时想创建一个实例，由于在一个时刻，只有一个线程能得到互斥锁，所以当第一个线程加上锁后，第二个线程就只能等待。当第一个线程发现实例还没有创建时，它就建立一个实例。接着第一个线程释放锁，此时第二个线程进入并上锁，这个时候由于实例已经被第一个线程创建出来了，第二个线程就不会重复创建实例了，这样就保证在多线程环境下只能得到一个实例。

　　但是，每次获取唯一实例，程序都会加锁，而加锁是一个非常耗时的操作，在没有必要的时候，我们要尽量避免，否则会影响性能。

---

 方法三：使用双重检查，提高效率，避免高并发场景下每次获取实例对象都进行加锁，并使用内存栅栏防止重排

class Singleton
{
public:
	//获取唯一对象实例的接口函数
	static Singleton* GetInstance()
	{
		// 使用双重检查，提高效率，避免高并发场景下每次获取实例对象都进行加锁
		if (_instance == NULL)
		{
			std::lock_guard<std::mutex> lck(_sMtx);
			if (_instance == NULL)
			{
				// tmp = new Singleton()分为以下三个部分
				// 1.分配空间2.调用构造函数3.赋值
				// 编译器编译优化可能会把2和3进行指令重排，这样可能会导致高并发场景下，其他线程获取到未调用构造函数初始化的对象
				// 以下加入内存栅栏进行处理，防止编译器重排栅栏后面的赋值到内存栅栏之前
				Singleton* tmp = new Singleton();
				MemoryBarrier(); //内存栅栏
				_instance = tmp;
			}
		}
		return _instance;
	}
	static void DelInstance()
	{
		if (_instance != NULL)
		{
			delete _instance;
			_instance = NULL;
		}
	}
	void Print()
	{
		cout << _data << endl;
	}
protected:
	//构造函数标记为protected或private，限制只能在类内创建对象
	Singleton()
		:_data(5)
	{}

	//防拷贝
	Singleton(const Singleton&);
	Singleton operator=(const Singleton&);

private:
	//指向实例的指针定义为静态私有，这样定义静态成员函数获取对象实例
	static Singleton* _instance;	  // 单实例对象
	int _data;								  // 单实例对象中的数据
	static mutex _sMtx;	              // 互斥锁
};
// 静态成员在类外初始化
Singleton* Singleton::_instance = NULL;
mutex Singleton::_sMtx;

　　试想，当实例还未创建时，由于 Singleton == NULL ，所以很明显，两个线程都可以通过第一重的 if 判断 ，进入第一重 if 语句后，由于存在锁机制，所以会有一个线程进入 lock 语句并进入第二重 if 判断 ，而另外的一个线程则会在 lock 语句的外面等待。而当第一个线程执行完 new  Singleton（）语句退出锁定区域，第二个线程便可以进入 lock 语句块，此时，如果没有第二重Singleton == NULL的话，那么第二个线程还是可以调用 new  Singleton（）语句，第二个线程仍旧会创建一个 Singleton 实例，这样也还是违背了单例模式的初衷的，所以这里必须要使用双重检查锁定（第二层if 判断必须存在）。

　  多数现代计算机为了提高性能而采取乱序执行，这使得内存栅栏成为必须。barrier就象是代码中的一个栅栏，将代码逻辑分成两段，barrier之前的代码和barrier之后的代码在经过编译器编译后顺序不能乱掉。也就是说，barrier之后的代码对应的汇编，不能跑到barrier之前去，反之亦然。之所以这么做是因为在我们这个场景中，如果编译器为了榨取CPU的performace而对汇编指令进行重排，其它线程获取到未调用构造函数初始化的对象，很有可能导致出错。

 　 只有第一次调用_instance为NULL，并且试图创建实例的时候才需要加锁，当_instance已经创建出来后，则没必要加锁。这样的修改比之前的时间效率要好很多。

但是这样的实现比较复杂，容易出错，我们还可以利用饿汉模式，创建相对简洁高效的单例模式。

---

方法四：饿汉模式--简洁、高效、不用加锁、但是在某些场景下会有缺陷

　　因为静态成员的初始化在程序开始时，也就是进入主函数之前，由主线程以单线程方式完成了初始化，所以静态初始化实例保证了线程安全性。在性能要求比较高时，就可以使用这种方式，从而避免频繁的加锁和解锁造成的资源浪费。

class Singleton
{
public:
	//获取唯一对象实例的接口函数
	static Singleton* GetInstance()
	{
		assert(_instance);
		return _instance;
	}
	void Print()
	{
		cout << _data << endl;
	}
protected:
	//构造函数标记为protected或private，限制只能在类内创建对象
	Singleton()
		:_data(5)
	{}

	//防拷贝
	Singleton(const Singleton&);
	Singleton operator=(const Singleton&);

private:
	static Singleton* _instance;	  // 单实例对象
	int _data;			 // 单实例对象中的数据
};
Singleton* Singleton::_instance = new Singleton;

　代码实现非常简洁。创建的实例_instance并不是在第一次调用GetInstance接口函数时才创建，而是在初始化静态变量的时候就创建一个实例。如果按照该方法会过早的创建实例，从而降低内存的使用效率。　

方法五：方法四还可以再简化点

class Singleton
{
public:
	//获取唯一对象实例的接口函数
	static Singleton* GetInstance()
	{
		static Singleton instance;
		return &instance;
	}
	void Print()
	{
		cout << _data << endl;
	}
protected:
	//构造函数标记为protected或private，限制只能在类内创建对象
	Singleton()
		:_data(5)
	{}

	//防拷贝
	Singleton(const Singleton&);
	Singleton operator=(const Singleton&);

private:
	int _data;	 // 单实例对象中的数据
};

---

　实例销毁

　此处使用了一个内部GC类，而该类的作用就是用来释放资源

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//带RAII GC自动回收实例对象的方式
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

class Singleton
{
public:
	// 获取唯一对象实例的接口函数
	static Singleton* GetInstance()
	{
		assert(_instance);
		return _instance;
	}
	// 删除实例对象
	static void DelInstance()
	{
		if (_instance)
		{
			delete _instance;
			_instance = NULL;
		}
	}
	void Print()
	{
		cout << _data << endl;
	}
	class GC
	{
	public:
		~GC()
		{
			cout << "DelInstance()" << endl;
			DelInstance();
		}
	};
private:
	Singleton()
		:_data(5)
	{}
	static Singleton*_instance;
	int _data;
};
// 静态对象在main函数之前初始化，这时只有主线程运行，所以是线程安全的。
Singleton* Singleton::_instance = new Singleton;
// 使用RAII，定义全局的GC对象释放对象实例
Singleton::GC gc;

　　　　在程序运行结束时，系统会调用Singleton中GC的析构函数，该析构函数会进行资源的释放。