如何在C++中实现多线程安全的单例模式？

作者

在现代C++（C++11及以后）中，线程安全的单例模式实现已经变得非常简洁，主要依赖于编译器保证的静态局部变量初始化以及标准库提供的同步原语。以下从几个常见方案入手，阐述实现细节、优缺点以及典型使用场景。

1. Meyers单例（局部静态变量）

class Singleton {
public:
    static Singleton& instance() {
        static Singleton inst;   // C++11 之后保证线程安全
        return inst;
    }
private:
    Singleton() = default;
    ~Singleton() = default;
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
};
  • 原理：instance()返回的局部静态对象在第一次被调用时初始化。自 C++11 起，标准规定该初始化是线程安全的，即使多个线程同时访问 instance() 也只会创建一次实例。
  • 优点：实现极其简洁，无需手写锁；销毁时依赖于程序退出时自动析构，避免手动管理。
  • 缺点：对象初始化的时机是“懒加载”，如果实例构造成本很高且不确定是否需要，可能导致启动时延迟；此外，无法在程序运行时显式销毁实例，导致内存泄漏在某些极端场景下不可接受。

2. std::call_once 与 std::once_flag

class Singleton {
public:
    static Singleton& instance() {
        std::call_once(flag_, [](){ inst_.reset(new Singleton); });
        return *inst_;
    }
private:
    Singleton() = default;
    static std::unique_ptr <Singleton> inst_;
    static std::once_flag flag_;
};

std::unique_ptr <Singleton> Singleton::inst_;
std::once_flag Singleton::flag_;
  • 原理：std::call_once 只会让第一个调用者执行 lambda 内的代码，随后所有调用者都会等待该初始化完成。相比 Meyers 单例，它显式展示了“只调用一次”的语义。
  • 优点：可以在初始化过程中执行更复杂的逻辑（如抛异常、日志等），并且可以配合 std::unique_ptr 或 std::shared_ptr 进行延迟销毁或资源共享。
  • 缺点：实现稍显冗长，且每次访问都需要检查 once_flag，理论上会有微小性能开销。

3. 双重检查锁（双重检查单例，DCL）

class Singleton {
public:
    static Singleton* instance() {
        if (inst_ == nullptr) {
            std::lock_guard<std::mutex> lock(mutex_);
            if (inst_ == nullptr) {
                inst_ = new Singleton;
            }
        }
        return inst_;
    }
private:
    Singleton() = default;
    static Singleton* inst_;
    static std::mutex mutex_;
};

Singleton* Singleton::inst_ = nullptr;
std::mutex Singleton::mutex_;
  • 原理：在多线程环境中先快速检查实例是否已存在，若不存在则加锁后再次检查再创建。适用于需要在类内部实现全局单例的情况。
  • 优点：在 C++11 之前是常见的实现方式，兼容旧编译器。
  • 缺点：需要手动管理内存，且存在“可见性”问题（编译器/CPU 重排），需要 volatile 或使用 std::atomic；C++11 之后更推荐使用 std::call_once 或局部静态变量。

4. 模板化单例（可定制化实例化）

template <typename T>
class Singleton {
public:
    static T& instance() {
        static T inst;
        return inst;
    }
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
};
  • 用法：`Singleton ::instance()` 即可得到 `MyClass` 的单例。适用于需要对多类统一实现单例模式的项目。

5. 与RAII结合的单例（可销毁）

如果你需要在程序执行过程中显式销毁单例，可以使用 std::shared_ptr 或 std::unique_ptr，并提供 destroy() 方法：

class Singleton {
public:
    static std::shared_ptr <Singleton> instance() {
        std::call_once(flag_, [](){ inst_.reset(new Singleton); });
        return inst_;
    }
    static void destroy() {
        std::call_once(flag_, [](){ /* nothing */ }); // 触发一次
        inst_.reset();
    }
private:
    Singleton() = default;
    static std::shared_ptr <Singleton> inst_;
    static std::once_flag flag_;
};

这样可以在 main() 结束前手动释放资源，防止某些静态对象析构顺序问题。

6. 常见坑与最佳实践

场景 建议方案 说明
C++11 及以后 Meyers 单例或 std::call_once 简洁且线程安全
旧编译器（C++03） 双重检查锁（DCL） 需要手动处理可见性
需要显式销毁 std::shared_ptr + destroy() 避免静态析构顺序问题
多类统一实现 模板化单例 简化代码，易于维护
构造函数抛异常 std::call_once + 异常安全 捕获异常后仍保证同步

7. 结语

C++ 的线程安全单例实现不再需要复杂的自定义锁或手工同步，现代标准提供了足够成熟的原语让实现既简洁又安全。开发者只需根据项目需求选择最适合的方案即可：如果只需要一次性、懒加载的全局对象，Meyers 单例是最优选；若需要更细粒度的控制或兼容旧编译器，std::call_once 或 DCL 仍是可行的备选。

祝你编码愉快 🚀

发表评论