一、单例模式的基本概念
单例模式可能是设计模式中最简单也最常用的一种了。它的核心思想很简单：确保一个类只有一个实例，并提供一个全局访问点。想象一下，你家里只有一个电饭煲，全家人做饭都得用它，这个电饭煲就是个单例。
在C++中实现单例看似简单，但其实暗藏玄机。我们先来看一个最基础的实现：
class Singleton {
public:
static Singleton& getInstance() {
static Singleton instance; // 局部静态变量
return instance;
}
// 删除拷贝构造函数和赋值运算符
Singleton(const Singleton&) = delete;
Singleton& operator=(const Singleton&) = delete;
private:
Singleton() {} // 私有构造函数
~Singleton() {} // 私有析构函数
};
这个实现看起来挺完美，利用了局部静态变量的特性，在C++11之后确实是线程安全的。但是，这里有几个关键点需要注意：
- 构造函数和析构函数都是私有的，防止外部创建和销毁实例
- 删除了拷贝构造函数和赋值运算符，防止通过拷贝方式创建新实例
- 使用静态局部变量，保证了线程安全（C++11及以上）
二、线程安全问题的深入探讨
虽然上面的实现在C++11之后是线程安全的，但如果我们回到C++11之前的世界，或者想了解底层原理，就需要深入探讨线程安全问题。
在多线程环境下，单例模式的初始化可能会遇到竞态条件。想象一下，两个线程同时调用getInstance()，可能会创建两个实例，这就违背了单例的初衷。
2.1 双重检查锁定模式
为了解决这个问题，前辈们发明了双重检查锁定模式(Double-Checked Locking Pattern)。先看代码：
class Singleton {
public:
static Singleton* getInstance() {
if (!instance) { // 第一次检查
std::lock_guard<std::mutex> lock(mutex);
if (!instance) { // 第二次检查
instance = new Singleton();
}
}
return instance;
}
// 删除拷贝构造函数和赋值运算符
Singleton(const Singleton&) = delete;
Singleton& operator=(const Singleton&) = delete;
private:
static Singleton* instance;
static std::mutex mutex;
Singleton() {}
~Singleton() {}
};
// 静态成员初始化
Singleton* Singleton::instance = nullptr;
std::mutex Singleton::mutex;
这个模式有两个关键点：
- 第一次检查不加锁，提高性能
- 第二次检查加锁，确保线程安全
但是！这个实现在某些编译器优化下可能会出问题，因为instance = new Singleton()不是原子操作，可能会被重排序。在C++11之前，这需要内存屏障来解决。
2.2 C++11之后的解决方案
C++11引入了内存模型，我们可以用原子操作来更优雅地解决这个问题：
#include <atomic>
#include <mutex>
class Singleton {
public:
static Singleton* getInstance() {
Singleton* 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 Singleton();
instance.store(tmp, std::memory_order_release);
}
}
return tmp;
}
// 删除拷贝构造函数和赋值运算符
Singleton(const Singleton&) = delete;
Singleton& operator=(const Singleton&) = delete;
private:
static std::atomic<Singleton*> instance;
static std::mutex mutex;
Singleton() {}
~Singleton() {}
};
// 静态成员初始化
std::atomic<Singleton*> Singleton::instance(nullptr);
std::mutex Singleton::mutex;
这个实现使用了原子操作和内存序，确保了线程安全，同时性能也很好。
三、单例模式的变体与高级话题
3.1 模板化的单例模式
如果我们有很多类都需要实现单例模式，可以写一个模板基类：
template <typename T>
class Singleton {
public:
static T& getInstance() {
static T instance;
return instance;
}
Singleton(const Singleton&) = delete;
Singleton& operator=(const Singleton&) = delete;
protected:
Singleton() {}
virtual ~Singleton() {}
};
// 使用示例
class Logger : public Singleton<Logger> {
friend class Singleton<Logger>;
public:
void log(const std::string& message) {
// 日志记录实现
}
private:
Logger() {} // 构造函数私有
};
这个模板实现非常优雅，任何需要单例的类只需要继承Singleton<T>即可。
3.2 单例的销毁问题
单例的销毁是个容易被忽视的问题。全局静态变量的销毁顺序是不确定的，如果单例之间有依赖关系，可能会出现问题。
Meyer's Singleton（就是我们第一个例子中的局部静态变量实现）的销毁是线程安全的，会在程序退出时自动调用析构函数。但是如果你需要手动控制销毁时机，可以这样实现：
class ManagedSingleton {
public:
static ManagedSingleton& getInstance() {
static ManagedSingleton instance;
return instance;
}
static void destroyInstance() {
// 这里可以添加自定义销毁逻辑
}
// 删除拷贝构造函数和赋值运算符
ManagedSingleton(const ManagedSingleton&) = delete;
ManagedSingleton& operator=(const ManagedSingleton&) = delete;
private:
ManagedSingleton() {}
~ManagedSingleton() {}
};
四、实际应用场景与最佳实践
4.1 适用场景
单例模式特别适合以下场景：
- 需要全局唯一访问点的资源，如配置文件、日志系统
- 重量级资源，如数据库连接池
- 需要集中管理的资源，如线程池、缓存系统
4.2 不适用场景
单例模式也不是万能的，以下情况要慎用：
- 需要多态行为的类
- 需要测试的代码（单例会使单元测试变复杂）
- 可能在未来需要多个实例的类
4.3 最佳实践建议
根据我的经验，给出几点建议：
- 在C++11及以上环境中，优先使用Meyer's Singleton实现
- 如果必须支持C++11之前的环境，使用双重检查锁定并确保正确使用内存屏障
- 考虑使用依赖注入替代单例，提高代码的可测试性
- 单例应该是无状态的，或者状态应该是应用级别的
- 文档中明确说明类的单例特性
4.4 一个完整的日志系统示例
让我们用一个完整的日志系统示例来结束本文：
#include <iostream>
#include <fstream>
#include <mutex>
#include <string>
class Logger {
public:
static Logger& getInstance() {
static Logger instance;
return instance;
}
void log(const std::string& message) {
std::lock_guard<std::mutex> lock(mutex_);
if (file_.is_open()) {
file_ << message << std::endl;
}
std::cout << message << std::endl; // 同时输出到控制台
}
// 删除拷贝构造函数和赋值运算符
Logger(const Logger&) = delete;
Logger& operator=(const Logger&) = delete;
private:
std::ofstream file_;
std::mutex mutex_;
Logger() {
file_.open("app.log", std::ios::app);
if (!file_.is_open()) {
std::cerr << "无法打开日志文件!" << std::endl;
}
}
~Logger() {
if (file_.is_open()) {
file_.close();
}
}
};
// 使用示例
int main() {
Logger::getInstance().log("应用程序启动");
// ... 其他代码
Logger::getInstance().log("应用程序退出");
return 0;
}
这个日志系统是线程安全的，同时将日志输出到文件和控制台，是一个非常实用的单例应用案例。
五、总结
实现线程安全的C++单例模式看似简单，实则需要考虑很多细节。随着C++标准的演进，我们有了更简单安全的实现方式。在C++11及以上环境中，局部静态变量的实现是最推荐的方式，它简洁、安全、高效。对于特殊需求，我们可以选择双重检查锁定或其他模式。
记住，单例模式是一把双刃剑，使用得当可以简化设计，滥用则会导致代码难以维护和测试。在实际项目中，要根据具体需求谨慎选择是否使用单例模式。
评论