单例模式的两种设计

单例模式确保一个类只有一个实例，并提供一个全局访问点。

1. 饿汉模式 (Eager Initialization)

饿汉模式在程序启动时就创建实例，线程安全。

cpp

复制代码

class EagerSingleton {
public:
    // 删除拷贝构造函数和赋值运算符
    EagerSingleton(const EagerSingleton&) = delete;
    EagerSingleton& operator=(const EagerSingleton&) = delete;
    
    // 提供全局访问点
    static EagerSingleton& getInstance() {
        return instance;
    }
    
    void doSomething() {
        std::cout << "EagerSingleton is doing something." << std::endl;
    }

private:
    // 私有构造函数
    EagerSingleton() = default;
    
    // 类加载时就初始化实例
    static EagerSingleton instance;
};

// 在类外初始化静态成员
EagerSingleton EagerSingleton::instance;

特点：

线程安全（因为实例在main函数之前初始化）
简单直接
可能造成资源浪费（如果从未使用）

2. 懒汉模式 (Lazy Initialization)

懒汉模式在第一次使用时才创建实例，需要考虑线程安全问题。

双重检查锁定版（传统线程安全实现）

cpp

复制代码

#include <mutex>

class DoubleCheckedLockingSingleton {
public:
    static DoubleCheckedLockingSingleton& getInstance() {
        if (instance == nullptr) {
            std::lock_guard<std::mutex> lock(mutex);
            if (instance == nullptr) {
                instance = new DoubleCheckedLockingSingleton();
            }
        }
        return *instance;
    }
    
    void doSomething() {
        std::cout << "DoubleCheckedLockingSingleton is doing something." << std::endl;
    }

private:
    DoubleCheckedLockingSingleton() = default;
    ~DoubleCheckedLockingSingleton() = default;
    DoubleCheckedLockingSingleton(const DoubleCheckedLockingSingleton&) = delete;
    DoubleCheckedLockingSingleton& operator=(const DoubleCheckedLockingSingleton&) = delete;
    
    static DoubleCheckedLockingSingleton* instance;
    static std::mutex mutex;
};

// 初始化静态成员
DoubleCheckedLockingSingleton* DoubleCheckedLockingSingleton::instance = nullptr;
std::mutex DoubleCheckedLockingSingleton::mutex;