设计线程安全的单例模式 ​

面试考点 ​

单例模式是面试中最常考的设计模式。面试官考察你是否理解各种单例实现的线程安全性:从 C++11 之前的双重检查锁定到 C++11 的 Meyer's Singleton 和 std::call_once,以及各方案的优缺点。

核心概念 ​

单例模式确保一个类只有一个实例,并提供全局访问点。线程安全的关键在于:多个线程同时首次访问实例时,只能有一个线程执行构造,其他线程等待构造完成后获取同一个实例。C++11 标准保证了局部静态变量初始化的线程安全性,使得 Meyer's Singleton 成为最简洁的线程安全实现。

基本示例 ​

cpp
#include <iostream>
#include <mutex>
#include <thread>
#include <vector>
#include <memory>
#include <atomic>

// ============================
// 方案1:Meyer's Singleton(推荐)
// ============================

// C++11 起线程安全,最简洁的实现
class Logger {
public:
    // 获取唯一实例
    static Logger& instance() {
        // C++11 标准 §6.7.4:
        // 如果多个线程同时进入此声明,并发执行将等待初始化完成
        static Logger logger;
        return logger;
    }

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

    // 禁止拷贝和移动
    Logger(const Logger&) = delete;
    Logger& operator=(const Logger&) = delete;
    Logger(Logger&&) = delete;
    Logger& operator=(Logger&&) = delete;

private:
    // 私有构造函数
    Logger() {
        std::cout << "Logger 构造(只执行一次)" << std::endl;
    }

    ~Logger() {
        std::cout << "Logger 析构" << std::endl;
    }

    std::mutex mutex_;
};

void meyers_demo() {
    // 多线程同时获取实例
    std::vector<std::thread> threads;
    for (int i = 0; i < 5; i++) {
        threads.emplace_back([i]() {
            Logger::instance().log("线程 " + std::to_string(i));
        });
    }
    for (auto& t : threads) t.join();
}

// ============================
// 方案2:std::call_once
// ============================

class Database {
public:
    static Database& instance() {
        // call_once 保证 init 只被调用一次
        std::call_once(init_flag_, []() {
            instance_.reset(new Database());
        });
        return *instance_;
    }

    void query(const std::string& sql) {
        std::cout << "[DB] 执行: " << sql << std::endl;
    }

    Database(const Database&) = delete;
    Database& operator=(const Database&) = delete;

private:
    Database() {
        std::cout << "Database 连接建立" << std::endl;
    }

    static std::unique_ptr<Database> instance_;
    static std::once_flag init_flag_;
};

std::unique_ptr<Database> Database::instance_;
std::once_flag Database::init_flag_;

void call_once_demo() {
    std::vector<std::thread> threads;
    for (int i = 0; i < 5; i++) {
        threads.emplace_back([]() {
            Database::instance().query("SELECT 1");
        });
    }
    for (auto& t : threads) t.join();
}

// ============================
// 方案3:双重检查锁定(DCLP)——教学用
// ============================

// C++11 之前的经典方案,现在不推荐使用
// 展示原理,面试时能讲清楚即可
class Config_DCLP {
public:
    static Config_DCLP* instance() {
        // 第一次检查(无锁,性能优化)
        Config_DCLP* tmp = instance_.load(std::memory_order_acquire);
        if (!tmp) {
            std::lock_guard<std::mutex> lock(mutex_);
            // 第二次检查(有锁,防止重复构造)
            tmp = instance_.load(std::memory_order_relaxed);
            if (!tmp) {
                tmp = new Config_DCLP();
                instance_.store(tmp, std::memory_order_release);
            }
        }
        return tmp;
    }

    std::string get(const std::string& key) {
        return "value_of_" + key;
    }

    Config_DCLP(const Config_DCLP&) = delete;
    Config_DCLP& operator=(const Config_DCLP&) = delete;

private:
    Config_DCLP() {
        std::cout << "Config 加载" << std::endl;
    }

    static std::atomic<Config_DCLP*> instance_;
    static std::mutex mutex_;
};

std::atomic<Config_DCLP*> Config_DCLP::instance_{nullptr};
std::mutex Config_DCLP::mutex_;

/*
DCLP 的内存序解释:
- 第一次 load 用 acquire:和 store 的 release 配对,
  确保看到 store 之前的所有写入(包括构造函数的写入)
- store 用 release:确保构造函数的所有写入在 store 之前完成
- 没有正确的内存序,可能看到一个"半构造"的对象
*/

// ============================
// 方案4:饿汉式(Eager Initialization)
// ============================

// 程序启动时就构造,不存在线程安全问题
class EagerSingleton {
public:
    static EagerSingleton& instance() {
        return instance_;
    }

    void do_work() {
        std::cout << "EagerSingleton 工作" << std::endl;
    }

    EagerSingleton(const EagerSingleton&) = delete;
    EagerSingleton& operator=(const EagerSingleton&) = delete;

private:
    EagerSingleton() {
        std::cout << "EagerSingleton 在 main 之前构造" << std::endl;
    }

    static EagerSingleton instance_;
};

EagerSingleton EagerSingleton::instance_;

/*
饿汉式的问题:
1. 静态初始化顺序未定义(SIOF):
   如果 A 的构造依赖 B,但 B 还没构造,就会出错
2. 即使不使用也会构造,浪费资源
3. 不能传构造参数
*/

// ============================
// 方案5:模板化单例(可复用)
// ============================

template<typename T>
class Singleton {
public:
    // 完美转发构造参数
    template<typename... Args>
    static T& instance(Args&&... args) {
        static T inst(std::forward<Args>(args)...);
        return inst;
    }

    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

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

// 使用模板化单例
class AppConfig : public Singleton<AppConfig> {
    friend class Singleton<AppConfig>;
    std::string app_name_;

    AppConfig(std::string name = "MyApp") : app_name_(std::move(name)) {
        std::cout << "AppConfig 创建: " << app_name_ << std::endl;
    }

public:
    const std::string& app_name() const { return app_name_; }
};

void template_demo() {
    auto& config = AppConfig::instance("TestApp");
    std::cout << "App: " << config.app_name() << std::endl;
}

int main() {
    std::cout << "=== Meyer's Singleton ===" << std::endl;
    meyers_demo();

    std::cout << "\n=== call_once ===" << std::endl;
    call_once_demo();

    std::cout << "\n=== 模板单例 ===" << std::endl;
    template_demo();

    return 0;
}

各方案对比 ​

方案线程安全延迟初始化复杂度推荐度
Meyer's SingletonC++11 起安全是最低最推荐
std::call_once安全是低推荐
双重检查锁定(DCLP)需要正确内存序是高不推荐
饿汉式天然安全否低场景受限
加锁整个方法安全是中性能差

析构顺序问题 ​

问题说明解决方案
静态对象析构顺序按构造的逆序析构确保依赖关系正确
析构后访问单例析构后被其他静态对象使用Phoenix Singleton 或不析构
多个单例互相依赖构造/析构顺序不确定用 Nifty Counter 或依赖注入

常见问题 ​

为什么 Meyer's Singleton 在 C++11 后是线程安全的?

C++11 标准 §6.7.4 明确规定:如果多个线程同时进入局部静态变量的声明,并发执行将等待初始化完成。编译器会自动插入必要的同步机制(通常是内部的 mutex 或 atomic flag)来保证这一点。

双重检查锁定为什么容易写错?

两个关键问题:1) 编译器和 CPU 可能重排指令,导致看到"半构造"的对象。2) 内存序必须正确:store 用 release,load 用 acquire,配对才能保证构造完成对其他线程可见。C++11 之前没有标准的内存模型,DCLP 在某些平台上不可靠。

单例模式有什么缺点?

  1. 全局状态使得单元测试困难(难以 mock);2) 隐式依赖关系(代码中到处调用 instance());3) 生命周期管理复杂(析构顺序问题)。现代 C++ 更推荐依赖注入,单例只在真正需要全局唯一实例时使用。

适用场景 ​

  • 日志系统(全局唯一的日志输出)
  • 配置管理器(全局配置只加载一次)
  • 数据库连接池(共享连接资源)
  • 线程池(全局唯一的任务执行器)

注意事项 ​

  • 优先使用 Meyer's Singleton(最简洁、最安全)
  • 禁止拷贝构造和赋值运算符
  • 注意静态对象的析构顺序
  • 单例的成员函数仍需要自己处理线程安全
  • 考虑是否真的需要单例,依赖注入通常是更好的设计

总结 ​

线程安全单例的最佳实现是 C++11 的 Meyer's Singleton(局部静态变量),一行代码搞定,标准保证线程安全。std::call_once 是次选方案。DCLP 复杂且容易出错,不推荐。饿汉式简单但有 SIOF 问题。面试中要能写出 Meyer's Singleton,解释为什么 C++11 保证其线程安全,说明 DCLP 的内存序要求,以及讨论单例模式的优缺点和替代方案。