【C++】单例中的懒汉和饿汉 以及线程安全问题

单例模式

单例模式含义：
简单来说：一个类只能创建一个对象，也就是确保一个类只有一个实例，并提供实例的全局访问点。

单例模式的实现：使用一个私有的构造函数 ，一个私有的静态变量以及一个共有的静态函数来实现。
因为私有的构造函数保证了不能通过构造函数来创建对象实例，只能通过共有的静态函数返回唯一的私有静态变量。

单例模式的两种实现：

饿汉模式-线程安全：

含义：在程序开始（main函数之前）之前，就先将所有资源准备好（最基本的就是创建一个唯一实例化对象）

例子：

class Singleton
{
public:
	static Singleton& GetInstance()
	{
		return _sInst;
	}
private:
	Singleton() // 将构造函数定义为私有，通过接口提供创建对象的函数
	{}

	Singleton(const Singleton&) = delete;  //防止拷贝构造

	static Singleton _sInst; // 对象在静态区
};

Singleton Singleton::_sInst; // 对单例对象的初始化

//验证
int main()
{
	cout << &Singleton::GetInstance() << endl;
	cout << &Singleton::GetInstance() << endl;
	cout << &Singleton::GetInstance() << endl;
	system("pause");
}

结果：
打印出来的都是相同的地址。因为对象在静态区，在程序开始之前就已经初始化好了。所以我们之后的访问都是对这个初始化完成的对象进行访问。

注意：在多线程下，没有线程完全的问题，因为对象的创建和实例化在main函数执行之前，并且只有一个。所以当多个线程一起通过GetInstance()访问对象，其实都是访问同一个对象。

优点：实现简洁
缺点：

1. 在main函数之前就初始化对象，创建资源。但是不保证后面会使用到。这样的话就会有很多的时间开销，程序启动慢。
2. 其次如果两个单例类有依赖关系，无法保证创建初始化实例的顺序

懒汉模式 - 线程不安全：

含义：什么时候用到什么数据，就在什么时候创建和初始化数据。

下面的实现中，私有变量_spInst被延迟实例化，这样做的好处是如果没有用到这个类，那么就不会实例化出对象，节省资源和时间开销。

问题：
但是这个实现是不安全的，如果多个线程同时进入if()条件判断，那么就会有多个线程执行_spInst = new Singleton语句，导致_spInst对象被实例化多次。

例子：

class Singleton1
{
public:
	static Singleton1& GetInstance()
	{
		if (_sInst == nullptr)
		{
			_sInst = new Singleton1;
			
		}
		return *_sInst;
	}
private:
	Singleton1()
	{}
	Singleton1(const Singleton&) = delete; 
	static Singleton1* _sInst; //对象在静态区
};

Singleton1* Singleton1::_sInst = nullptr;

我们将上述的饿汉模式的例子改为线程安全的：
双重校验锁-线程安全

#include <vector>
#include <mutex>

class Singleton
{
public:
	static Singleton& GetInstance()
	{
		// 双检查解锁的效率问题
		if (_spInst == nullptr)
		{
			_smtx.lock();
			if (_spInst == nullptr)
			{
				_spInst = new Singleton;
			}
			_smtx.unlock();
		}

		return *_spInst;
	}

private:
	// 构造函数私有化
	Singleton()
	{}

	Singleton(const Singleton&) = delete;

	static Singleton* _spInst;
	static mutex _smtx;
};

Singleton* Singleton::_spInst = nullptr; // main函数之前就创建初始化指针
mutex Singleton::_smtx; // main函数之前初始化锁。

我们直接在判断语句if()的地方加上了互斥锁_mutx，那么在一个时间点，只能有一个线程能够进入判断语句并且只实例化一次，避免实例化多次。

双重校验锁：
先判断_spInst 是否已经被实例化，如果没有被实例化，那么对实例化的语句进行加锁。也就是通过一次判断就可以避免多个线程加锁、判断、解锁的过程，大大的提高了效率。

注意：我们从代码中就可以看出。懒汉模式不是线程安全的。 因为当多个线程都进入if (_spInst == nullptr)，就会实例化出多个对象，所以我们要加锁，来保证它只能实例化出一个对象。

优点

1. 是在第一次调用时候创建实例，不影响程序的启动。
2. 调用时创建初始化，顺序可以控制

缺点：

1. 懒汉模式非线程安全
2. 双重校验锁下的是线程安全的(但是不一定，会存在CPU乱序的问题）

饿汉模式与懒汉模式的对比:

我们可以看出来，懒汉模式中尽管我们是在main函数之前就初始化我们的对象指针，但是我们是在要实例化对象的时候，也就是第一次要调用GetInstance()函数的时候，在堆上开辟了一块对象的空间。
但是在饿汉模式中，是在一开始就在静态区直接实例化出一个对象，函数都可以访问到这个全局的对象。