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

作者

在现代 C++ 开发中，单例模式经常被用来保证全局资源的唯一实例，例如日志系统、配置管理器或线程池。然而，在多线程环境下实现一个既安全又高效的单例，仍然是一个细致的工程。本文将从设计原则、常见实现方式、以及性能与可维护性的平衡出发，详细剖析几种实现多线程安全单例的方法，并给出实用建议。

1. 单例的基本要求

  1. 唯一性：整个程序生命周期内只能存在一个实例。
  2. 全局可访问：任何地方都可以通过统一接口获得该实例。
  3. 延迟初始化：实例在第一次被请求时才创建，避免不必要的开销。
  4. 线程安全：在多线程环境下，实例的创建与访问不应产生竞争或死锁。

2. 常用实现方式

2.1 局部静态变量（C++11 及以上）

class Logger {
public:
    static Logger& instance() {
        static Logger instance; // 线程安全的局部静态
        return instance;
    }

    void log(const std::string& msg) {
        std::lock_guard<std::mutex> lock(mtx_);
        // 写日志逻辑
    }

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

    std::mutex mtx_;
};

优点

  • 简单易懂，利用 C++11 的局部静态初始化保证线程安全。
  • 只会在第一次调用时初始化，后续调用几乎无开销。

缺点

  • 无法控制实例的销毁时机（通常在程序结束时由运行时处理）。
  • 对于需要在特定时刻销毁资源的场景（例如共享库卸载），不够灵活。

2.2 双重检查锁（Lazy+Mutex）

class Config {
public:
    static Config* getInstance() {
        if (!instance_) {
            std::lock_guard<std::mutex> lock(init_mtx_);
            if (!instance_) {
                instance_ = new Config();
            }
        }
        return instance_;
    }

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

    static Config* instance_;
    static std::mutex init_mtx_;
};

Config* Config::instance_ = nullptr;
std::mutex Config::init_mtx_;

优点

  • 只在真正需要时创建实例，适用于资源昂贵的对象。

缺点

  • 需要手动管理内存，可能导致内存泄漏或销毁顺序问题。
  • 代码稍显冗长，容易出现错误。

2.3 std::call_once（现代推荐）

class Service {
public:
    static Service& getInstance() {
        std::call_once(init_flag_, []() {
            instance_ = new Service();
        });
        return *instance_;
    }

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

    static Service* instance_;
    static std::once_flag init_flag_;
};

Service* Service::instance_ = nullptr;
std::once_flag Service::init_flag_;

优点

  • 语义清晰，保证只执行一次初始化。
  • 兼容 C++11 之后的标准，线程安全。

缺点

  • 需要手动销毁实例（如果想在程序退出前释放）。

2.4 std::shared_ptr + std::atomic（可控制生命周期）

class Engine {
public:
    static std::shared_ptr <Engine> getInstance() {
        std::shared_ptr <Engine> tmp = instance_.load();
        if (!tmp) {
            std::lock_guard<std::mutex> lock(mtx_);
            tmp = instance_.load();
            if (!tmp) {
                tmp = std::make_shared <Engine>();
                instance_.store(tmp);
            }
        }
        return tmp;
    }

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

    static std::atomic<std::shared_ptr<Engine>> instance_;
    static std::mutex mtx_;
};

std::atomic<std::shared_ptr<Engine>> Engine::instance_{nullptr};
std::mutex Engine::mtx_;

优点

  • 通过 shared_ptr 自动管理内存，避免泄漏。
  • 线程安全的读取和写入，适用于高并发读取场景。

缺点

  • 代码相对繁琐，使用 atomic 与 shared_ptr 的组合需要谨慎。

3. 性能与可维护性评估

实现方式 延迟初始化 线程安全 代码复杂度 资源销毁
局部静态变量 ✔ ✔ ★ 由运行时
双重检查锁 ✔ ✔ ★★ 需要手动
call_once ✔ ✔ ★ 需要手动
shared_ptr+atomic ✔ ✔ ★★ 自动
  • 对于大多数场景，局部静态变量 或 std::call_once 已经足够。
  • 如果你需要在库中或插件系统中显式销毁单例，建议使用 call_once 并配合 std::shared_ptr。
  • 双重检查锁在 C++11 之后已不再推荐，主要是因为局部静态已内置优化。

4. 常见陷阱与最佳实践

  1. 析构顺序问题

    • 如果单例持有其他全局对象，销毁顺序可能导致悬空引用。
    • 通过 std::atexit 或 call_once 的 std::shared_ptr 可以降低风险。

  2. 异常安全

    • 在构造函数中抛异常时，单例的内部状态可能被置为部分初始化。
    • 使用 call_once 的 lambda 中捕获异常并重置 instance_，保证下一次调用可以重新尝试。

  3. 跨线程共享

    • 当单例内部维护状态（如计数器）时，需要使用互斥锁或原子操作。
    • 只在必要时上锁，避免频繁的锁竞争。

  4. 测试与验证

    • 用多线程单元测试验证单例在高并发下的唯一性。
    • 使用 std::async 或 std::thread 创建大量线程，统一调用 instance()，检查返回地址是否一致。

5. 结语

多线程安全的单例并不一定要复杂。现代 C++ 提供了成熟的工具，如局部静态变量、std::call_once 与 std::shared_ptr，帮助我们在保证线程安全的前提下，写出简洁、易维护的代码。根据实际需求选择合适的实现方式，并注意资源生命周期与异常安全，便能在项目中稳固地使用单例模式。

发表评论