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

作者

在多线程环境下实现一个线程安全的单例（Singleton）是许多 C++ 开发者经常遇到的挑战。常见的实现方式有“双检锁（Double-Check Locking）”、Meyers’ Singleton、以及使用 std::call_once 与 std::once_flag。下面我们逐一探讨这些实现，并给出完整可编译的示例代码。

1. 双检锁（Double-Check Locking）

双检锁思想是先不加锁检查实例是否已经创建，若未创建再加锁并再次检查。其实现需要注意内存模型（C++11 之后的标准）以及 volatile 或 std::atomic 的使用。

#include <atomic>
#include <mutex>

class Singleton {
public:
    static Singleton& instance() {
        // 第一次检查，避免不必要的加锁
        Singleton* tmp = instance_.load(std::memory_order_acquire);
        if (!tmp) {
            std::lock_guard<std::mutex> lock(mutex_);
            tmp = instance_.load(std::memory_order_relaxed);
            if (!tmp) {
                tmp = new Singleton();
                instance_.store(tmp, std::memory_order_release);
            }
        }
        return *tmp;
    }

    // 禁止复制和移动
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
    Singleton(Singleton&&) = delete;
    Singleton& operator=(Singleton&&) = delete;

    void doSomething() { /* ... */ }

private:
    Singleton() = default;
    ~Singleton() = default;

    static std::atomic<Singleton*> instance_;
    static std::mutex mutex_;
};

std::atomic<Singleton*> Singleton::instance_{nullptr};
std::mutex Singleton::mutex_;

优点：实例化时只加一次锁，性能相对较好。
缺点：实现繁琐，容易出现细微的错误（如内存可见性、对象初始化顺序等）。

2. Meyers’ Singleton

C++11 之后的标准保证局部静态变量在首次进入作用域时的初始化是线程安全的。最简洁的实现方式是：

class Singleton {
public:
    static Singleton& instance() {
        static Singleton instance;  // C++11 线程安全
        return instance;
    }

    void doSomething() { /* ... */ }

private:
    Singleton() = default;
    ~Singleton() = default;
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
};

优点：代码简洁，且在 C++11 之后天然线程安全。
缺点：若需要在程序结束时手动销毁实例（例如需要自定义销毁顺序），该方式不太适合。

3. std::call_once 与 std::once_flag

std::call_once 与 std::once_flag 是 C++11 提供的线程安全一次性初始化工具，能够保证即使在多线程环境下也只执行一次指定的函数。

#include <memory>
#include <mutex>

class Singleton {
public:
    static Singleton& instance() {
        std::call_once(flag_, []() { instance_.reset(new Singleton()); });
        return *instance_;
    }

    void doSomething() { /* ... */ }

private:
    Singleton() = default;
    ~Singleton() = default;
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

    static std::unique_ptr <Singleton> instance_;
    static std::once_flag flag_;
};

std::unique_ptr <Singleton> Singleton::instance_;
std::once_flag Singleton::flag_;

优点：明确表达“一次性初始化”，代码可读性好。
缺点：需要手动管理实例的生命周期（如使用 unique_ptr 或裸指针）。

4. 对比与推荐

方法 代码量 线程安全保证 性能 适用场景
双检锁 适中 通过 atomic + mutex 中等 需要自定义销毁
Meyers’ 极少 标准保证 高 简单单例
call_once 适中 call_once 保证 中等 需要自定义销毁

对于大多数现代 C++ 项目，Meyers’ Singleton 是首选。它既简洁又可靠。若项目要求在程序退出时精确控制销毁顺序，或需要自定义构造参数，则可考虑 std::call_once。

5. 常见陷阱

  1. 析构函数可见性：若单例是裸指针，必须保证在程序退出前不被销毁（如通过 atexit 注册）。
  2. 多继承或虚继承：单例类不应作为多继承基类，否则可能导致 typeid 与 RTTI 的不一致。
  3. 资源泄漏：若单例管理的资源是全局唯一的（如文件句柄、网络连接），应在析构中安全释放。
  4. 测试：单例在单元测试中难以重置，可通过依赖注入或提供 reset()（仅在测试环境下）来解决。

6. 结语

在 C++ 中实现线程安全的单例并非难题，关键是了解标准库所提供的工具与内存模型。使用 Meyers' Singleton 或 std::call_once 能让代码既简洁又安全。若需要更细粒度的控制，可采用双检锁或手动 std::mutex 与 std::atomic 的组合。通过上述方法，你可以在任何多线程项目中安全地使用单例模式。

发表评论