单例模式详细讲解
一.定义
单例模式是一种创建型设计模式，确保一个类只有一个实例，并提供一个全局访问点
特点：
1.构造函数和析构函数私有化
2.禁用拷贝构造函数和赋值运算符重载（=delete）
3.利用静态成员函数和静态成员变量来给外界提供访问
二.恶汉式
恶汉是非常霸道的，由此可见，对于恶汉式，我们程序加载时立即创建单例实例（无论是否需要）
代码如下:
//恶汉式:
class Singleton
{
public://利用静态成员函数和静态成员变量来给外界提供访问static Singleton GetInstance(){return _instance;} //禁用拷贝构造和赋值运算符Singleton(const Singleton&) =delete;Singleton& operator=(const Singleton&)=delete;
priavte://构造析构私有化：Singleton(){}~Singleton(){}static Singleton _instance;//定义一个对象
};
//static类外实例化:
Singleton Singleton::_instance;优点：
线程安全（C++11保证静态变量的线程安全初始化）
程序启动时就创建实例
简单直接
缺点：
本质是通过空间换来的，可能导致空间浪费
三.懒汉式
懒汉本质在于懒，说明只有当我们需要时才会创建单例对象，具有延迟实例化特点，通过调用GetInstance()函数来创建对象
优点;
按需创建对象，避免浪费空间
缺点：
基础实现是非线程安全的，需额外处理多线程问题
下面我们一一来讲解不同版本：
//懒汉式：
//初始版本--1
class Singleton
{
public：static Singleton* GetInstance(){if(nullptr==_instance){//创建对象_instance =new Singleton;}return _instance;}//禁用拷贝构造和赋值运算符Singleton(const Singleton&) =delete;Singleton& operator=(const Singleton&)=delete;
priavte://构造析构私有化：Singleton(){}~Singleton(){}static Singleton* _instance;//定义一个对象指针
};
//类对象实例化：
Singleton* Singleton::_instance=nullptr;该版本问题如下：
该代码不是线程、进程安全的，具体是指如果多个线程同时调用到GetInstance中的if语句且都进入，就会new两个以上对象，无法确保只有一个类对象
解决方法：加锁
//懒汉式：
//初始版本--2
#include <mutex>
class Singleton
{
public：static Singleton* GetInstance(){//单检测法： _mutex.lock();if(nullptr==_instance){//创建对象_instance =new Singleton;}_mutex.unlock();return _instance;}//禁用拷贝构造和赋值运算符Singleton(const Singleton&) =delete;Singleton& operator=(const Singleton&)=delete;
priavte://构造析构私有化：Singleton(){}~Singleton(){}static Singleton* _instance;//定义一个对象指针static std::mutex _mutex;
};
//类对象实例化：
Singleton* Singleton::_instance=nullptr;
std::mutex Singleton::_mutex;上面我们利用C++中提供的锁解决了多线程问题，但是如果每次访问都要加锁，并且多线程访问只有一个能够进去，其他要等待，性能非常不好
下面我们来利用双检测法来解决问题：
//懒汉式：
//初始版本--3
#include <mutex>
class Singleton
{
public：static Singleton* GetInstance(){//双检测法： if(nullptr==_instance){_mutex.lock();if(nullptr==_instance){//创建对象 _instance =new Singleton;}_mutex.unlock();}return _instance;}//禁用拷贝构造和赋值运算符Singleton(const Singleton&) =delete;Singleton& operator=(const Singleton&)=delete;
priavte://构造析构私有化：Singleton(){}~Singleton(){}static Singleton* _instance;//定义一个对象指针static std::mutex _mutex;
};
//类对象实例化：
Singleton* Singleton::_instance=nullptr;
std::mutex Singleton::_mutex;该双检测法并非是正确的双检测法，原因：如果CPU执行new的指令发生问题，即如果先返回对象指针，这样就会接受到一个nullptr的指针，出现问题
newCPU执行过程;
1.分配空间 malloc
2.调用构造函数 （类）
3.返回对象指针
下面我们来学习正确的双检测法;
//懒汉式：
//初始版本--4
#include <mutex>
#include <atmoic>
class Singleton
{
public：static Singleton* GetInstance(){//双检测法： (正确写法）Singleton* tmp = _instance.load(std::memory_order_relaxed);//std::memory_order_relaxed---C++11 引入,最宽松的内存顺序约束，仅保证原子性，不提供线程间的同步或顺序保证std::atomic_thread_fence(std::memory_order_acquire); if(nullptr==_instance){_mutex.lock();tmp = _instance.load(std::memory_order_relaxed);if (tmp == nullptr) {tmp = new Singleton();std::atomic_thread_fence(std::memory_order_release);_instance.store(tmp, std::memory_order_relaxed);}_mutex.unlock();}return tmp;}//禁用拷贝构造和赋值运算符Singleton(const Singleton&) =delete;Singleton& operator=(const Singleton&)=delete;
priavte://构造析构私有化：Singleton(){}~Singleton(){}static std::atomic<Singleton*> _instance;;//定义一个对象指针static std::mutex _mutex;
};
//类对象实例化：
std::atomic<Singleton*> Singleton::_instance(nullptr);
std::mutex Singleton::_mutex;利用Atomic来保证原子性，保证双检测不会受到CPU执行指令顺序影响
优点：
线程安全，高性能（只有第一次需要加锁）
缺点：
实现复杂，需要注意内存屏障
最后，我们来学习发明单例模式的作者是如何写的:
//作者实现的：
class Singleton
{
public:static Singleton& getInstance() {static Singleton instance;return instance;}Singleton(const Singleton&) = delete;Singleton& operator=(const Singleton&) = delete;private:Singleton() {}~Singleton() {}
};
特点;
线程安全（C++11保证局部静态变量的线程安全初始化）
延迟初始化
简洁高效
不需要考虑内存释放问题
（只能说不愧是大佬！！！）
其实我们也可以考虑下智能指针和call_once来实现，大家可以试试
最后，感谢你的浏览，点个关注吧！！！