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

作者

在 C++ 里，单例模式是一种常见的设计模式，旨在保证某个类只有一个实例，并提供全局访问点。随着多线程程序的普及，传统单例实现往往无法满足并发访问时的线程安全需求。下面将介绍几种在 C++17 及以上标准下实现线程安全单例的方案，并讨论它们的优缺点。

1. Meyer’s 单例（局部静态变量）

最简单、最推荐的实现方式是利用函数内部的局部静态变量。C++11 之后，局部静态变量的初始化已被保证为线程安全。

class Singleton {
public:
    static Singleton& instance() {
        static Singleton instance;   // C++11 之后的线程安全初始化
        return instance;
    }
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
private:
    Singleton() = default;
    ~Singleton() = default;
};

优点

  • 代码简洁：无需手动锁定或使用互斥量。
  • 延迟初始化：真正需要时才创建实例。
  • 生命周期管理：C++ 的静态对象在程序结束时自动销毁。

缺点

  • 控制不够细粒度：无法在构造期间捕获异常或自定义销毁顺序。
  • 在多线程程序中可能出现多次初始化的情况（仅在 C++03 时需要考虑，C++11 以后已不再是问题）。

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

如果你需要在 C++11 之前实现线程安全单例，或者想要更细致地控制初始化过程，可以使用双重检查锁定结合 std::call_once。

#include <mutex>

class Singleton {
public:
    static Singleton& instance() {
        std::call_once(initFlag, [](){ instancePtr = new Singleton(); });
        return *instancePtr;
    }
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
private:
    Singleton() = default;
    ~Singleton() = default;
    static Singleton* instancePtr;
    static std::once_flag initFlag;
};

Singleton* Singleton::instancePtr = nullptr;
std::once_flag Singleton::initFlag;

优点

  • 可跨平台：适用于 C++03 及更早版本。
  • 显式控制：你可以在 call_once 里放入更复杂的初始化逻辑。

缺点

  • 代码相对冗长：需要手动管理指针和销毁。
  • 存在细节错误风险：如忘记删除实例导致内存泄漏。

3. 静态局部对象与 std::shared_ptr

如果单例对象需要在程序结束前按特定顺序销毁（例如在依赖于其他单例的情况下），可以使用 std::shared_ptr 包装实例。

class Singleton {
public:
    static std::shared_ptr <Singleton> instance() {
        static std::shared_ptr <Singleton> ptr(new Singleton());
        return ptr;
    }
    // ...
private:
    Singleton() = default;
};

std::shared_ptr 的构造和销毁过程是线程安全的，且可以让你在销毁时做自定义操作。

4. 模板实现通用单例

当你需要为多个类提供相同的单例实现时，可以把单例逻辑封装成一个模板。

template<typename T>
class SingletonTemplate {
public:
    static T& instance() {
        static T instance;
        return instance;
    }
    SingletonTemplate(const SingletonTemplate&) = delete;
    SingletonTemplate& operator=(const SingletonTemplate&) = delete;
protected:
    SingletonTemplate() = default;
    ~SingletonTemplate() = default;
};

使用时：

class MyService : public SingletonTemplate <MyService> {
    friend class SingletonTemplate <MyService>;
private:
    MyService() { /* 初始化 */ }
    // ...
};

5. 常见坑与注意事项

  1. 析构函数
    单例对象的析构在程序退出时才会执行。若单例在析构过程中访问了已被销毁的其他单例，可能导致访问违规。使用 std::shared_ptr 或者在析构中手动销毁所有单例可降低风险。

  2. 异常安全
    在构造过程中抛出异常会导致实例未完全初始化。使用 std::call_once 或局部静态对象能保证异常后再次调用时仍能安全重试。

  3. 静态对象销毁顺序
    静态局部对象的销毁顺序是按逆序（LIFO）执行的。若单例间存在依赖关系，建议使用 std::shared_ptr 或显式销毁顺序。

  4. 线程上下文切换
    std::call_once 的实现使用了轻量级互斥，适合高并发环境；相比之下，手动 std::mutex 的锁竞争更激烈。

6. 小结

在现代 C++（C++11 及以后）中，最推荐的实现单例的方式是 Meyer’s 单例（局部静态变量）。它简洁、可靠、延迟初始化且已线程安全。如果你需要在更早的标准下实现或者想对单例的创建和销毁做更细粒度控制，std::call_once 或 std::shared_ptr 都是不错的选择。了解并掌握这些实现方式，有助于你在多线程 C++ 项目中安全、有效地使用单例模式。

发表评论