---

一、单例模式的特点

一个类，只应该实例化了一个对象，就是单例。

二、饿汉模式实现单例

举个饿汉模式的例子：洗碗，一个人吃碗饭之后，他马上洗碗，下次吃饭的时候就可以直接拿起碗吃饭了。这就是饿汉模式。
懒汉模式是：一个人吃完饭之后，他先不洗碗，下次吃饭的时候再洗碗，这就是懒汉模式。
懒汉模式的核心特点是：延迟加载。

饿汉模式实现单例：
template<class T>
class Singleton
{
private:
	static T inst;

public:
	static T* GetInstance()
	{
		return &inst;
	}
};

通过SingleTon类实例化的对象只能拥有一个。

三、懒汉模式实现单例

懒汉模式具体是什么已经介绍过了。
下面用代码实现懒汉模式

懒汉模式实现单例
template<class T>
class Singleton
{
private:
	static T* inst;

public:
	static T* GetInstance()
	{
		if(inst == nullptr)
			inst  = new T();
			
		return inst;
	}
};

但是这样的懒汉模式存在线程安全，假如有两个线程同时进入GetInstance函数中new T()呢？
这样就会存在两个inst指针指向的对象了， 就不再是单例了。

所以需要加锁保证线程安全。
下面是线程安全版本的单例模式

template <class T>
class Singleton
{
private:
	static std::mutex lock;
	volatile static T* inst;  //设置volatile关键字的目的是防止被编译器优化
public:
	static T* GetInstance()
	{
		lock.lock();
		if(inst == nullptr)		//判断的本质也是再访问临界资源，所以要在加锁之后
			inst = new T();
		lock.unlock();
		return inst;
	}

这样解决了线程并发问题，但是这样假如有大量线程同时进入该函数时，会并发竞争锁，会造成性能低下，极端情况下可能出现卡顿现象。
因为不管有没有实例化T对象，都会进行锁竞争，这是不太合理的。

正确的应该是：如果没有实例化T对象，先申请锁对T对象new一个出来。
如果有了T对象，直接返回即可。
下面是改正后的代码：

template <class T>
class Singleton
{
private:
	static std::mutex lock;
	volatile static T* inst;  //设置volatile关键字的目的是防止被编译器优化
public:
	static T* GetInstance()
	{
		if(inst == nullptr)   //双重判定空指针, 降低锁冲突的概率, 提高性能
		{
			lock.lock();
			if(inst == nullptr)   //判断的本质也是再访问临界资源，所以要在加锁之后
				inst = new T();
			lock.unlock();
		}
		return inst;
	}
	

};

这样实现懒汉模式的单例模式，解决了线程安全+性能低下的问题。

四、STL线程安全吗？

不是
原因是, STL 的设计初衷是将性能挖掘到极致, 而一旦涉及到加锁保证线程安全, 会对性能造成巨大的影响.而且对于不同的容器, 加锁方式的不同, 性能可能也不同(例如hash表的锁表和锁桶).
因此 STL 默认不是线程安全. 如果需要在多线程环境下使用, 往往需要调用者自行保证线程安全

五、智能指针线程安全吗？

对于 unique_ptr, 由于只是在当前代码块范围内生效, 因此不涉及线程安全问题
对于 shared_ptr, 多个对象需要共用一个引用计数变量, 所以会存在线程安全问题.但是标准库实现的时候考虑到了这个问题， 基于原子操作(CAS)的方式保证 shared_ptr 能够高效， 原子的操作引用计数