设计线程安全的单例模式
面试考点
单例模式是面试中最常考的设计模式。面试官考察你是否理解各种单例实现的线程安全性:从 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 Singleton | C++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 在某些平台上不可靠。
单例模式有什么缺点?
- 全局状态使得单元测试困难(难以 mock);2) 隐式依赖关系(代码中到处调用 instance());3) 生命周期管理复杂(析构顺序问题)。现代 C++ 更推荐依赖注入,单例只在真正需要全局唯一实例时使用。
适用场景
- 日志系统(全局唯一的日志输出)
- 配置管理器(全局配置只加载一次)
- 数据库连接池(共享连接资源)
- 线程池(全局唯一的任务执行器)
注意事项
- 优先使用 Meyer's Singleton(最简洁、最安全)
- 禁止拷贝构造和赋值运算符
- 注意静态对象的析构顺序
- 单例的成员函数仍需要自己处理线程安全
- 考虑是否真的需要单例,依赖注入通常是更好的设计
总结
线程安全单例的最佳实现是 C++11 的 Meyer's Singleton(局部静态变量),一行代码搞定,标准保证线程安全。std::call_once 是次选方案。DCLP 复杂且容易出错,不推荐。饿汉式简单但有 SIOF 问题。面试中要能写出 Meyer's Singleton,解释为什么 C++11 保证其线程安全,说明 DCLP 的内存序要求,以及讨论单例模式的优缺点和替代方案。