【多线程】线程安全的单例模式

什么是单例模式

单例模式是一个设计模式，其目的是确保一个类只有一个实例，并提供一个全局的访问点来访问该实例。单例模式常用于需要控制资源数量的场景，比如数据库连接池、日志管理器等。下面介绍常见的单例模式的实现方式。

饿汉实现方式

观察下面代码：

class EagerSingleton {
private:
    // 私有构造函数，防止外部实例化
    EagerSingleton() {}

    // 禁用拷贝构造函数和赋值运算符
    EagerSingleton(const EagerSingleton&) = delete;
    EagerSingleton& operator=(const EagerSingleton&) = delete;

    // 静态实例，类加载时初始化
    static EagerSingleton instance;

public:
    // 提供全局访问点
    static EagerSingleton& getInstance() {
        return instance;
    }
};

// 初始化静态实例
EagerSingleton EagerSingleton::instance;

要想实现单例，从两个方面入手：1.如何实现禁止构造2个或者2个以上的实例化对象。2.如何实现只构造一个对象。
对于前者，我们可以将构造函数私有化，这样就不能在类外部构造对象了。那怎么保证拥有一个实例化对象呢？这一点可以在类中使用static修饰一个该类的实例对象，这样就能在程序加载的时候自动创建一个实例化对象，由于static成员属于类本身的特性，所以能使用私有的构造函数，且只会加载一次。

要想使用这个单例，就需要一个static修饰的成员方法专门用来提供全局的访问点，因为static成员函数可以直接通过类名使用，不需要创建实例化对象。 此外静态成员变量需要在类外部初始化。

饿汉实现模式的特点

• 类加载的时候实例化
• 私有化构造函数
• 线程安全：由于实例化是在类加载的时候完成的，且类加载的过程中由C++标准保证了线程安全，因此不需要额外的同步机制来保证线程安全。

懒汉实现方式

观察下面代码

class LazySingleton {
private:
    // 私有的静态指针变量，用于指向唯一的实例
    static LazySingleton* instance;

    // 私有构造函数，防止外部实例化
    LazySingleton() {}

public:
    // 提供全局访问点
    static LazySingleton* getInstance() {
        if (instance == nullptr) {
            instance = new LazySingleton();
        }
        return instance;
    }
};

// 初始化静态指针变量
LazySingleton* LazySingleton::instance = nullptr;

注意其中和饿汉实现方式的区别，懒汉实现单例模式中static修饰的是一个实例对象的指针。这样一来，类加载的时候就不会构造自动一个实例化对象。具体的观察这一段代码：

static LazySingleton* getInstance() {
        if (instance == nullptr) {
            instance = new LazySingleton();
        }
        return instance;
    }

这一段代码保证了该类只能实例化对象一次，且只在第一次调用getInstance() 函数时才会创建。这样一来也能实现单例模式。但是和饿汉模式不一样的是，这种单例模式只在第一次使用的时候实例化一个对象，而饿汉模式是程序开始时不管你用不用都会实例化一个。这种机制又被称为延迟实例化机制。此外，这种机制在多线程模式下是不安全的。比如可能会有多个线程
new LazySingleton();
为了保证线程安全，我们需要使用锁来保证创建实例化对象时同步。例如下面代码：

#include <mutex>

class LazySingleton {
private:
    static LazySingleton* instance;
    static std::mutex mtx;
    LazySingleton() {}

public:
    static LazySingleton* getInstance() {
        std::lock_guard<std::mutex> lock(mtx);
        if (instance == nullptr) {
            instance = new LazySingleton();
        }
        return instance;
    }
};

// 初始化静态变量
LazySingleton* LazySingleton::instance = nullptr;
std::mutex LazySingleton::mtx;

上面加锁方式在每次调用getInstance()这个函数的时候都会加一次锁，频繁的调用该函数可能会造成一定的性能问题。
对于上面加锁方式还可以进一步进行优化，例如采用双重检查锁定，具体优化的代码如下：

#include <mutex>

class LazySingleton {
private:
    static LazySingleton* instance;
    static std::mutex mtx;
    LazySingleton() {}

public:
    static LazySingleton* getInstance() {
        if (instance == nullptr) {
            std::lock_guard<std::mutex> lock(mtx);
            if (instance == nullptr) {
                instance = new LazySingleton();
            }
        }
        return instance;
    }
};

// 初始化静态变量
LazySingleton* LazySingleton::instance = nullptr;
std::mutex LazySingleton::mtx;

这样一来，只有在首次创建对象时会上锁，其余时候都不会也不需要。

懒汉实现方式的特点

• 线程不安全
• 延迟实例化
• 需要使用互斥锁保证线程安全
  具体原因分析上面已经阐述过了，这里就不做过多分析了。