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

在 C++11 之后，标准库已为多线程环境提供了原子操作、互斥锁、条件变量等原语，使得实现线程安全的单例模式比以前更简单、更可靠。下面将从设计原则、常见实现方式以及性能与可维护性三个角度，系统阐述如何在 C++ 中实现一个线程安全且高效的单例。

1. 单例模式的基本思路

单例模式的目标是保证全局只存在唯一实例，并在需要时提供访问入口。实现时常见的关键点包括：

私有化构造函数，防止外部直接实例化。
删除拷贝构造和赋值运算符，避免通过拷贝产生新的实例。
提供静态访问函数，返回实例引用或指针。

在单线程环境下，简单的 static 局部变量即可满足需求：

class Singleton {
private:
    Singleton() = default;
public:
    static Singleton& instance() {
        static Singleton instance;
        return instance;
    }
};

但在多线程环境下，若多个线程同时调用 instance()，可能导致两次实例化（竞态条件）。C++11 对局部静态变量的初始化进行了线程安全保证，然而在某些编译器实现或编译选项下，仍可能出现微小的性能开销。因此，常用的实现方案分为三类：懒汉式、双重检查锁、Meyers 单例（C++11 之上）。下面分别展开讨论。

2. 方案一：Meyers 单例（C++11+）

Meyers 单例利用 C++11 对局部静态变量初始化的线程安全保证，代码最简洁，性能也非常好。

class Singleton {
private:
    Singleton() { /* 资源初始化 */ }
    ~Singleton() { /* 资源释放 */ }
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
public:
    static Singleton& get() {
        static Singleton instance;
        return instance;
    }
    // 业务方法示例
    void doSomething() const { /* ... */ }
};

优点

实现简单：无显式锁、无条件变量。
性能优秀：C++11 标准库保证只在第一次访问时初始化一次，随后只做指针返回。
线程安全：编译器层面确保初始化不会被并发破坏。

注意事项

销毁时机：局部静态会在程序结束时自动析构，若需要提前销毁可使用 std::atexit 或手动提供 destroy()。
异常安全：若构造函数抛异常，第二次访问时会重新尝试初始化，符合标准行为。

3. 方案二：双重检查锁（懒汉式）

如果你在旧编译器（C++03）或特殊环境下需要手动实现线程安全，可采用双重检查锁。关键思路是先检查实例是否已存在，若不存在则加锁并再次检查，最后创建实例。

#include <mutex>

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

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

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

优点

兼容 C++03：无需依赖 C++11 的线程安全静态初始化。
延迟创建：实例仅在首次请求时创建。

缺点

复杂度高：易出错，需保证锁的正确使用。
潜在性能损失：每次访问都要检查指针，且在第一次访问时锁竞争。
内存泄漏：若不手动销毁，new 的实例可能不会被回收。

4. 方案三：使用 `std::call_once`

C++11 引入了 std::call_once 和 std::once_flag，可以在多线程环境下保证某个函数只被调用一次。结合 std::unique_ptr 可以实现单例，且无需手动管理锁。

#include <memory>
#include <mutex>

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

    static std::unique_ptr <Singleton> instance_;
    static std::once_flag initFlag_;
    static void init() { instance_.reset(new Singleton()); }

public:
    static Singleton& get() {
        std::call_once(initFlag_, init);
        return *instance_;
    }
};

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

优点

线程安全：std::call_once 保证 init() 只执行一次。
资源管理：使用 unique_ptr 自动析构，避免手动 delete。
延迟初始化：仅在首次调用 get() 时执行。

缺点

性能开销：std::call_once 内部实现相对复杂，稍有性能损耗。
可读性：对初学者可能稍显晦涩。

5. 性能与可维护性对比

方案	代码复杂度	线程安全	性能	可维护性
Meyers	★	★★（C++11+）	★★★★	★★★★
双重检查锁	★★	★★	★★	★★
`call_once`	★★	★★	★★★	★★★

Meyers 方案在现代 C++（C++11 及以上）中是最推荐的，代码最简洁、最安全。
双重检查锁 仅在需要兼容旧标准时使用，维护成本较高。
call_once 方案在需要显式控制初始化逻辑或想在单例内部使用动态分配时可选。

6. 实际使用场景

全局资源管理：如日志系统、数据库连接池、配置管理器等。
插件或驱动加载：只需一次实例化，避免重复加载。
跨模块共享：保证所有模块使用同一实例，保持状态一致。

7. 进阶技巧

延迟销毁：若想在程序结束前主动销毁单例，可提供 destroy() 并在 atexit 注册。
多线程异常安全：若构造函数抛异常，std::call_once 会在下次调用时再次尝试。
测试多线程：使用 std::thread 或测试框架（如 GoogleTest）编写并发访问单例的单元测试。

8. 小结

在 C++ 中实现线程安全的单例模式并不需要过多的代码。现代 C++ 标准已提供足够的工具（局部静态变量、std::once_flag、std::call_once），只要遵循以下三条原则即可：

私有化构造、删除拷贝，保证唯一实例。
使用标准线程安全原语，避免手写锁。
避免资源泄漏，尽量使用 RAII 方式管理实例。

选择最适合项目编译环境与需求的方案，即可在保证线程安全的同时，获得最佳性能与代码可维护性。