【单例模式】饿汉式与懒汉式以及线程安全

1. 单例模式介绍

饿汉式单例模式：还没有获取实例对象，实例对象就已经产生了。一定是线程安全的。

懒汉式单例模式：需要用的时候再构造实例。

应用场景：比如日志模块，数据库模块，开发的解析器模块。

2.饿汉式单例实现

2.1构造步骤

构造函数私有化
定义一个唯一的类的静态实例对象（类内声明类外初始化）
获取类的唯一实例对象的接口方法
删除拷贝构造和赋值函数

cpp 复制代码

// 饿汉式单例模式
class Singleton
{
public:
    static Singleton* getInstance() // 3. 获取类的唯一实例对象的接口方法
    {
        return &instance;
    }

private:
    static Singleton instance;  // 2. 定义一个唯一的类的实例对象

    Singleton() // 1. 构造函数私有化
    {

    }

   // 4. 删除拷贝构造 和 赋值函数
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
};
Singleton Singleton::instance;  // 类内声明类外初始化

2.2饿汉式单例特点

饿汉式单例模式一定是线程安全的。

缺点：对象的实例化构造中可能需要做很多东西，程序中用不到也会执行，程序运行前耗费太多时间。希望在需要用的时候再构造实例。

3.懒汉式单例实现

3.1懒汉式单例实现步骤

就是将饿汉式单例的实例对象定义为指针。

cpp 复制代码

// 懒汉式单例模式 ==> 是不是线程安全呢？
class Singleton
{
public:
    // 是不是可重入函数呢？
    static Singleton* getInstance() // 3. 获取类的唯一实例对象的接口方法
    {
        if(instance == nullptr)
        {
            /*
            1 开辟内存
            2 给instance赋值
            3 构造对象  
            */
            instance = new Singleton();
        }

        return instance;
    }

private:
    static Singleton *instance;  // 2. 定义一个唯一的类的实例对象

    Singleton() // 1. 构造函数私有化
    {

    }

   // 4. 删除拷贝构造 和 赋值函数
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
};
Singleton *Singleton::instance = nullptr;  // 类内声明类外初始化

3.2懒汉式单例特点

不是一个线程安全的：编译器也许会指令优化如2 3顺序可能不同 ==> 多个线程可能会出问题 ==> 不是可重入函数，使用锁实现互斥。

4.实现线程安全的单例模式

4.1实现思路

lock_gard放在if上面会导致锁的粒度太大
放在if里面要注意使用"锁+双重判断"（防止两个线程都进入if构造两个实例）。
instance在数据段，由统一进程内多个线程共享，cpu为了加快指令执行，会让线程共享的内存值都拷贝一份放自己缓存里，需要给指针加关键字volatile。好处是：当一个线程给instance赋值的时候，其他线程马上就能看到instance改变，因为线程已经不对这个共享变量进行缓存了。

线程安全的懒汉式单例模式：

cpp 复制代码

// 懒汉式单例模式 ==> 是不是线程安全呢？  ==> 线程安全的懒汉式单例模式
std::mutex mtx;
class Singleton
{
public:
    // 是不是可重入函数呢？     锁+双重判断
    static Singleton* getInstance() // 3. 获取类的唯一实例对象的接口方法
    {
        // std::lock_guard<std::mutex> guard(mtx); // 锁的粒度太大了
        if(instance == nullptr)
        {
            std::lock_guard<std::mutex> guard(mtx);
            if(instance == nullptr)
            {
                /*
                1 开辟内存
                2 给instance赋值
                3 构造对象  
                编译器也许会指令优化如2 3顺序可能不同 ==> 多个线程可能会出问题 ==> 不是可重入函数，使用锁实现互斥。
                */
                instance = new Singleton();
            }

        }

        return instance;
    }

private:
    static Singleton *volatile instance;  // 2. 定义一个唯一的类的实例对象
    Singleton() // 1. 构造函数私有化
    {

    }

    // 4. 删除拷贝构造 和 赋值函数
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
};
Singleton *volatile Singleton::instance = nullptr;  // 类内声明类外初始化

4.2更精简的线程安全的懒汉式单例模式

参考文献列在最后了！

cpp 复制代码

// 线程安全的懒汉式单例模式（更精简）
class Singleton
{
public:
    static Singleton* getInstance() // 3. 获取类的唯一实例对象的接口方法
    {
        // 静态的局部变量，程序开始内存就有了，在数据段上。
        // 静态对象在第一次运行到的时候才进行初始化。没运行getInstance就不会构造实例。

        // g++ -g -o run singleton.cpp  gdb run
        // 函数静态局部变量的初始化，在汇编指令上已经自动添加线程互斥指令了。
        static Singleton instance;  // 2. 定义一个唯一的类的实例对象。

        return &instance;
    }

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

    }

    // 4. 删除拷贝构造 和 赋值函数
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
};

这种构造使用静态局部变量的特点：

// 静态的局部变量，程序开始内存就有了，在数据段上。

// 静态对象在第一次运行到的时候才进行初始化。没运行getInstance就不会构造实例。

通过

// g++ -g -o run singleton.cpp gdb run

// 函数静态局部变量的初始化，在汇编指令上已经自动添加线程互斥指令了。

在Linux环境中，通过g++编译上面的代码，命令如下：
g++ -o main main.cpp -g

生成可执行文件main，用gdb进行调试，到getInstance函数，并打印该函数的汇编指令，如下：

可以看到：对于static静态局部变量的初始化，编译器会自动对它的初始化进行加锁和解锁控制，使静态局部变量的初始化成为线程安全的操作，不用担心多个线程都会初始化静态局部变量，因此上面的懒汉单例模式是线程安全的单例模式！

参考博客：C++设计模式 - 单例模式_大秦坑王设计模式-CSDN博客