一.定义

        单例模式是一种创建型设计模式，确保一个类只有一个实例，并提供一个全局访问点

特点：

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来实现，大家可以试试

最后，感谢你的浏览，点个关注吧！！！