c++如何实现单例模式_c++ 饿汉式与懒汉式线程安全实现【方法】_技术教程

饿汉式单例启动即初始化，天然线程安全；懒汉式首次调用才创建，需用std::call_once或双重检查锁定保障线程安全，但易出错，推荐优先使用饿汉式。

饿汉式单例：启动即初始化，天然线程安全

饿汉式在程序加载时就完成实例构造，后续所有调用都直接返回已创建的对象指针，不存在多线程竞争问题，无需加锁。

关键点在于 static 成员变量的初始化时机由编译器保证——C++11 起，static 局部变量的初始化是线程安全的；而静态成员变量（如类内定义的 static Instance*）在 main() 执行前完成，且仅一次。

常见错误是把指针声明和 new 拆开写，导致非原子操作：

class Singleton {
private:
    static Singleton* instance;
    Singleton() = default;  // 防止外部构造
public:
    static Singleton* getInstance() {
        return instance;  // ❌ instance 可能为 nullptr 或未初始化
    }
};
Singleton* Singleton::instance = new Singleton();  // ✅ 此行才真正构造

更推荐写法（C++11+）：

立即学习“C++免费学习笔记（深入）”；

class Singleton {
private:
    Singleton() = default;
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
public:
    static Singleton& getInstance() {
        static Singleton instance;  // ✅ 局部静态变量，线程安全初始化
        return instance;
    }
};

必须禁用拷贝构造与赋值，否则可能意外复制出多个对象
返回引用比返回指针更安全，避免用户误删或置空
析构顺序不可控：局部静态对象在 main 结束后按逆序销毁，若其他静态对象依赖它，可能访问已析构对象

懒汉式单例：首次调用才创建，需手动保障线程安全

懒汉式延迟资源占用，但 getInstance() 中的判空 + 构造逻辑不是原子操作，多线程下极易出现重复 new 或返回未完全构造的对象。

典型错误写法（双重检查锁定漏锁）：

static Singleton* getInstance() {
    if (instance == nullptr) {           // 第一次检查
        instance = new Singleton();      // ❌ 构造+赋值非原子，可能被重排，其他线程看到半初始化对象
    }
    return instance;
}

正确实现（C++11 double-checked locking pattern）：

class Singleton {
private:
    static std::atomic instance;
    static std::mutex mtx;
    Singleton() = default;
public:
    static Singleton* getInstance() {
        Singleton* tmp = instance.load(std::memory_order_acquire);
        if (tmp == nullptr) {
            std::lock_guard lock(mtx);
            tmp = instance.load(std::memory_order_relaxed);
            if (tmp == nullptr) {
                tmp = new Singleton();
                instance.store(tmp, std::memory_order_release);
            }
        }
        return tmp;
    }
};
std::atomic Singleton::instance{nullptr};
std::mutex Singleton::mtx;

必须用 std::atomic 替代裸指针，否则无法防止指令重排
memory_order_acquire 和 memory_order_release 保证构造完成后再对其他线程可见
两次判空缺一不可：第一次避免无谓加锁，第二次防止加锁后已被其他线程创建
不建议手写 DCLP —— 容易出错，优先用局部静态变量（饿汉式）或 std::call_once

更现代的懒汉式替代：std::call_once + once_flag

相比手写 DCLP，std::call_once 更简洁、不易出错，且由标准库保证绝对只执行一次。

class Singleton {
private:
    static Singleton* instance;
    static std::once_flag init_flag;
    Singleton() = default;
public:
    static Singleton* getInstance() {
        std::call_once(init_flag, []() {
            instance = new Singleton();
        });
        return instance;
    }
};
Singleton* Singleton::instance = nullptr;
std::once_flag Singleton::init_flag;