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

作者

在多线程环境下，单例模式（Singleton）需要保证只有一个实例被创建，并且所有线程都能安全地访问该实例。下面从设计原则、实现细节、以及常见陷阱三个角度，给出一种既简洁又安全的实现方法，并对比几种常见方案。

1. 设计原则

原则 说明
懒加载 只在第一次需要时才创建实例，节省资源。
线程安全 多线程并发访问时，避免出现多个实例。
高效 创建实例后访问尽量快，避免不必要的锁。
可测试 能够在单元测试中注入或重置实例。

2. 经典实现：std::call_once + std::once_flag

C++11 引入的 std::call_once 与 std::once_flag 能让我们在多线程环境下实现一次性初始化，而不需要手动管理锁。代码如下：

#include <iostream>
#include <mutex>
#include <memory>

class Singleton {
public:
    // 获取单例实例
    static Singleton& instance() {
        std::call_once(initFlag, [](){
            // 使用智能指针隐藏裸指针
            instancePtr.reset(new Singleton());
        });
        return *instancePtr;
    }

    // 业务方法示例
    void doSomething() const {
        std::cout << "Doing something. Instance address: " << this << std::endl;
    }

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

private:
    Singleton() = default;  // 私有构造函数
    ~Singleton() = default; // 私有析构函数（如果需要自动销毁则去掉）
    static std::unique_ptr <Singleton> instancePtr;
    static std::once_flag initFlag;
};

// 静态成员定义
std::unique_ptr <Singleton> Singleton::instancePtr = nullptr;
std::once_flag Singleton::initFlag;

说明

  1. std::once_flag：只会被 std::call_once 调用一次，保证初始化只执行一次。
  2. std::call_once：在多线程环境下安全调用传入的 lambda，内部使用原子操作和必要的同步。
  3. std::unique_ptr：避免裸指针，管理生命周期。若希望单例在程序结束前销毁，可以保留 unique_ptr；若不销毁，删除析构函数即可。

3. 另一种实现：函数内部静态局部变量

自 C++11 起，局部静态变量的初始化是线程安全的。代码更短：

class Singleton {
public:
    static Singleton& instance() {
        static Singleton instance;  // 线程安全的局部静态
        return instance;
    }
    // 业务方法
    void doSomething() const { /* ... */ }

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

优点：简洁，编译器自动保证线程安全。

缺点：若想在程序结束时显式销毁实例，需要手动设计。默认情况下，局部静态会在程序退出时销毁，但若存在跨线程资源竞争，可能导致析构顺序问题。

4. 性能对比与最佳实践

方案 线程安全性 代码量 资源占用 适用场景
call_once + once_flag 高 中 需要 unique_ptr + once_flag 需要显式控制销毁或更细粒度的初始化
函数局部静态 高 低 轻量 典型单例场景，生命周期不受限

小结：对于大多数 C++ 项目，使用函数内部静态变量实现单例是最推荐的方式。它的实现最短、最安全、最易维护。若你需要更复杂的生命周期管理（例如在程序结束前手动销毁，或者需要在单元测试中注入替代实现），则使用 std::call_once 与 std::unique_ptr 的组合更合适。

5. 常见陷阱

  1. 全局析构顺序
    如果单例持有其他全局对象，程序结束时析构顺序可能导致访问已析构对象。使用 std::call_once 可以在 main() 之后手动销毁，避免此问题。

  2. 跨线程递归调用
    在单例内部递归调用 instance() 可能导致死锁（尤其使用自定义锁时）。避免在构造函数中调用 instance()。

  3. 多继承
    单例基类与多重继承可能导致二义性，最好使用纯粹的单继承或使用 CRTP。

  4. 测试替换
    在单元测试中，若需要替换单例实现，最好将 instance() 改为可注入接口或使用依赖注入框架。

6. 代码示例：完整可编译的演示

#include <iostream>
#include <thread>
#include <mutex>
#include <memory>

class Logger {
public:
    static Logger& get() {
        static Logger instance;
        return instance;
    }

    void log(const std::string& msg) {
        std::lock_guard<std::mutex> lock(mutex_);
        std::cout << "[" << std::this_thread::get_id() << "] " << msg << std::endl;
    }

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

    std::mutex mutex_;
};

void worker(int id) {
    Logger::get().log("Thread started");
    // 模拟工作
    std::this_thread::sleep_for(std::chrono::milliseconds(100));
    Logger::get().log("Thread finished");
}

int main() {
    std::thread t1(worker, 1);
    std::thread t2(worker, 2);
    t1.join(); t2.join();
    return 0;
}

运行结果显示所有日志都来自同一个 Logger 实例，且线程安全。

7. 结语

单例模式在 C++ 中既有其经典的“魔法”实现，也有可维护的现代实现。通过 std::call_once 与 std::once_flag 或者函数内部静态变量，开发者可以在保证线程安全的前提下，以最小代码量完成单例设计。理解它们的底层实现与潜在陷阱，有助于在实际项目中做出更稳健的决策。祝编码愉快！

发表评论