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

作者

在多线程环境下，单例模式常被用于控制全局唯一实例的创建与访问。若实现不当，可能出现竞态条件导致多实例被创建，甚至出现数据竞争。下面给出一种现代C++（C++11及以后）实现线程安全单例的典型方法，并分析其优缺点。

1. 使用局部静态变量（Meyer’s Singleton）

class Singleton {
public:
    static Singleton& instance() {
        static Singleton inst;   // C++11 规定局部静态变量初始化是线程安全的
        return inst;
    }

    // 禁止拷贝构造和赋值
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

    void doSomething() {
        // 业务逻辑
    }

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

优点

  • 简洁：只需一行代码即可完成线程安全初始化。
  • 延迟加载：首次调用 instance() 时才创建对象。
  • 自动销毁：程序退出时局部静态会被析构。

缺点

  • 可能导致在多线程环境下出现一次昂贵的锁竞争，虽然实现已被优化为“锁无开销”的方式，但在某些平台仍有微小开销。
  • 对于需要在多线程中频繁访问单例的场景，锁的开销不可忽视。

2. 双重检查锁（Double-Check Locking）

class Singleton {
public:
    static Singleton* instance() {
        if (!inst_) {                         // 第一检查
            std::lock_guard<std::mutex> lock(mtx_);
            if (!inst_) {                     // 第二检查
                inst_ = new Singleton();
            }
        }
        return inst_;
    }

    // 同上...

private:
    Singleton() = default;
    ~Singleton() = default;
    static Singleton* inst_;
    static std::mutex mtx_;
};

Singleton* Singleton::inst_ = nullptr;
std::mutex Singleton::mtx_;

优点

  • 控制对象只在第一次创建时获取锁，后续访问无锁开销。

缺点

  • 需要手动管理内存，可能导致析构顺序问题。
  • 在 C++11 之前容易出现“可见性”问题，必须确保使用 std::atomic 或 std::memory_order，但在 C++11 标准实现中仍有风险。

3. 线程安全的懒汉式（使用 std::call_once）

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

    // 同上...

private:
    Singleton() = default;
    ~Singleton() = default;
    static Singleton* inst_;
    static std::once_flag flag_;
};

Singleton* Singleton::inst_ = nullptr;
std::once_flag Singleton::flag_;

优点

  • std::call_once 保证一次且只一次的初始化，避免多线程竞争。
  • 代码更简洁，且无显式锁操作。

缺点

  • 同样需要手动析构（如果想让析构在程序结束时自动触发，可使用 std::unique_ptr 或 std::shared_ptr 与自定义删除器）。

4. 对象销毁顺序与资源管理

若单例持有系统资源（文件句柄、网络连接等），需要在程序结束前显式释放。最简单方法是使用 std::unique_ptr 并让其在全局析构期间自动销毁：

class Singleton {
public:
    static Singleton& instance() {
        static std::unique_ptr <Singleton> inst(new Singleton());
        return *inst;
    }
    // ...
};

或者使用 std::shared_ptr 配合自定义删除器来控制释放时机。

5. 性能评估

  • 局部静态变量：几乎无锁开销（C++17 后已实现无锁初始化），是大多数项目首选。
  • 双重检查锁：在高并发时可略快于局部静态变量，但实现更复杂。
  • std::call_once：性能介于两者之间，代码清晰。

6. 何时使用单例？

  • 需要全局唯一实例且不需要频繁销毁。
  • 对象初始化成本高，但只需要一次。
  • 线程安全且易于维护。

7. 总结

在 C++11 及以后，推荐使用局部静态变量实现单例，因其实现简单、线程安全且性能优秀。若需要更细粒度的控制或兼容旧标准，可考虑 std::call_once 或双重检查锁。无论哪种方式，记住禁止拷贝构造和赋值，确保实例唯一性。

发表评论