单例模式：线程安全的饿汉、懒汉还搞不懂？

单例模式

单例模式意思是：一个类不论创建多少次，永远都只能得到该类的一个实例对象，日志模块通常这么设计。

单例模式通常有两种，饿汉式和懒汉式，我们一一来讲解。

饿汉式

见名知意，看见饭跟没见过吃的似的，生怕自己吃不到。
为了限制对象的构造个数，我们就需要限制构造函数的访问方式，同时将拷贝构造和赋值函数delete掉。

1. 构造函数私有化
2. 定义一个唯一的类对象
3. 完成获取类的唯一实例对象的接口方法

完整实现如下

class Singleton
{
public:
    static Singleton *getInstance() // #3
    {
        return &instance;
    }

private:
    static Singleton instance; // #2
    Singleton()                // #1
    {
    }
    Singleton(const Singleton &) = delete;
    Singleton &operator=(const Singleton &) = delete;
};
Singleton Singleton::instance; //注意这里要初始化

是否线程安全？
因为类的对象在一开始就已经构造好了对象，主函数中只是在调用相应接口获取对象的使用权，因此这种模式对象创建一定是线程安全的。

存在的问题
实际开发项目中单例模式的类可能有很多，但不一定在每个模块都会调用使用，这种情况就产生问题了，类在加载时就会创建相应的对象（不论是否有用），会造成空间大量浪费，而懒汉式就解决了这一问题。

懒汉式

这个对象能不创建就不创建！实在不行等你用的时候我再创建！我懒啊！

定义一个类对象指针初始化nullptr，每次调用getInstance()时指针为空，才会创建对象。

class Singleton
{
public:
    static Singleton *getInstance() // #3
    {
        if (instance == nullptr) //只有为空才创建
        {
            instance = new Singleton();
        }
        return instance;
    }

private:
    static Singleton *instance; // #2
    Singleton()                 // #1
    {
    }
    Singleton(const Singleton &) = delete;
    Singleton &operator=(const Singleton &) = delete;
};
Singleton *Singleton::instance Ï= nullptr; //初始化类对象指针

接下来我们考虑线程安全的问题。
我们假设线程1在调用getInstance()运行到if语句里面时，时间片用完被交给线程2，此时线程1还没有创建对象并给instance赋值(实际上创建对象、赋值的两个分开的操作)，线程2这时候也进入到了getInstance()里面创建对象并赋值给了instance，时间片还给线程1时，又一次对instance构造赋值。
因此，这种设计是不满足线程安全的

如何修改？
我们可以考虑引入互斥锁来避免竞态条件，实现如下

static Singleton *getInstance() // #3
    {
        if (instance == nullptr)
        {
            lock_guard<mutex> guard(mutex);
            if (instance == nullptr)
            {
                instance = new Singleton();
            }
        }
        return instance;
    }

为什么我们要在if里面再次判断instance是否为空？
举个例子，如果不加里面那一层判断条件，线程1在执行到锁范围内的语句时时间片耗尽，线程2过来等待锁资源的释放，接着线程1执行完毕后释放锁，线程2获得锁以后还会重复执行构造赋值操作，还是没有避免掉这个问题。
因此我们这里引入了二重判断，这也是多线程情况比较常用的方法！
下面是完整代码

mutex mtx;
class Singleton
{
public:
    static Singleton *getInstance() // #3
    {
        if (instance == nullptr)
        {
            lock_guard<mutex> guard(mutex);
            if (instance == nullptr)
            {
                instance = new Singleton();
            }
        }
        return instance;
    }

private:
    static Singleton *volatile instance; // #2
    Singleton()                          // #1
    {
    }
    Singleton(const Singleton &) = delete;
    Singleton &operator=(const Singleton &) = delete;
};
Singleton *volatile Singleton::instance = nullptr;

心细的朋友可能就看到了，为什么私有创建的类对象要加volatile？
我们知道每个线程为了提高执行效率，会将常用变量数据放到缓存器中，volatile关键字就是杜绝这一行为，每次都从内存里面去读取这个值，这样就使得线程1在对一个变量做了改变，线程2立马就会知道。

懒汉加强版！！！！！

我们只需要改写getInstance()方法

static Singleton *getInstance() // #3
    {
        static Singleton instance;
        return &instance;
    }

这样线程安全吗？
静态对象，空间在程序启动就有了，不过在程序运行到它时才被初始化。难道不会产生 线程1构造对象时构造函数只执行了一部分代码 线程2就介入，构造对象重复初始化这个问题吗？
如果我们进入汇编指令下看会发现，函数静态局部变量的初始化过程，系统时自动添加了线程互斥指令的，因此上述问题是不会发生的！

收工！！！