单例模式的核心是保证一个类在程序中只有一个实例，并且提供全局访问点，在很多需要全局唯一管理资源的场景比如日志管理器、配置管理器中应用广泛。如果单例实例在程序退出时没有被正确销毁，就可能出现内存泄漏、文件句柄未关闭、网络连接未断开等问题，影响程序的稳定性和资源利用率。
单例模式的基础实现
最基础的单例模式实现会私有化构造函数、拷贝构造函数和赋值运算符，对外提供一个静态的获取实例的方法，以下是一个简单的饿汉式单例示例：
#include <iostream>
class Singleton {
private:
// 私有化构造函数，禁止外部直接创建实例
Singleton() {
std::cout << "Singleton 构造" << std::endl;
}
// 私有化拷贝构造和赋值运算符，防止实例被拷贝
Singleton(const Singleton&) = delete;
Singleton& operator=(const Singleton&) = delete;
public:
// 静态方法获取唯一实例
static Singleton* getInstance() {
static Singleton instance;
return &instance;
}
void doSomething() {
std::cout << "单例执行操作" << std::endl;
}
};
程序退出时单例销毁的潜在风险
如果使用动态内存分配的方式实现单例，比如通过new创建实例却不主动释放，程序退出时就会导致内存泄漏。另外如果单例之间依赖关系复杂，可能出现销毁顺序问题，比如单例A依赖单例B，但是程序退出时单例B先被销毁，之后单例A再调用单例B的方法就会出现未定义行为。
动态分配单例的销毁问题示例
以下是不安全的一种单例实现，只在获取实例时创建，没有对应的销毁逻辑：
class UnsafeSingleton {
private:
UnsafeSingleton() {}
static UnsafeSingleton* instance;
public:
static UnsafeSingleton* getInstance() {
if (instance == nullptr) {
instance = new UnsafeSingleton();
}
return instance;
}
};
// 初始化静态成员
UnsafeSingleton* UnsafeSingleton::instance = nullptr;
上面的实现中，instance指向的内存永远不会被释放，程序退出时就会产生内存泄漏。
安全销毁单例的几种方案
方案一：使用静态局部变量实现单例
C++11之后，静态局部变量的初始化是线程安全的，而且静态局部变量会在程序退出时自动调用析构函数销毁，不需要开发者手动管理生命周期，是最简单的实现方式。
#include <iostream>
class SafeSingleton {
private:
SafeSingleton() {
std::cout << "SafeSingleton 构造" << std::endl;
}
~SafeSingleton() {
std::cout << "SafeSingleton 析构" << std::endl;
}
SafeSingleton(const SafeSingleton&) = delete;
SafeSingleton& operator=(const SafeSingleton&) = delete;
public:
static SafeSingleton& getInstance() {
static SafeSingleton instance;
return instance;
}
void func() {
std::cout << "SafeSingleton 执行功能" << std::endl;
}
};
int main() {
SafeSingleton::getInstance().func();
// 程序退出时，静态局部变量instance会自动析构
return 0;
}
方案二：结合智能指针和atexit注册销毁函数
如果需要更灵活的控制销毁逻辑，可以使用std::shared_ptr管理单例实例，同时通过std::atexit注册销毁函数，在程序退出时主动释放资源。
#include <iostream>
#include <memory>
#include <cstdlib>
class SmartSingleton {
private:
SmartSingleton() {
std::cout << "SmartSingleton 构造" << std::endl;
}
~SmartSingleton() {
std::cout << "SmartSingleton 析构" << std::endl;
}
SmartSingleton(const SmartSingleton&) = delete;
SmartSingleton& operator=(const SmartSingleton&) = delete;
static std::shared_ptr<SmartSingleton> instance;
static void destroyInstance() {
if (instance != nullptr) {
instance.reset();
}
}
public:
static std::shared_ptr<SmartSingleton> getInstance() {
if (instance == nullptr) {
instance = std::make_shared<SmartSingleton>();
std::atexit(destroyInstance);
}
return instance;
}
void work() {
std::cout << "SmartSingleton 工作" << std::endl;
}
};
// 初始化静态智能指针
std::shared_ptr<SmartSingleton> SmartSingleton::instance = nullptr;
int main() {
auto singleton = SmartSingleton::getInstance();
singleton->work();
return 0;
}
方案三：嵌套垃圾回收类实现销毁
可以在单例内部嵌套一个垃圾回收类，利用静态垃圾回收实例的析构函数来完成单例实例的销毁，这种方式也可以保证销毁逻辑在程序退出时自动执行。
#include <iostream>
class GC_Singleton {
private:
GC_Singleton() {
std::cout << "GC_Singleton 构造" << std::endl;
}
~GC_Singleton() {
std::cout << "GC_Singleton 析构" << std::endl;
}
GC_Singleton(const GC_Singleton&) = delete;
GC_Singleton& operator=(const GC_Singleton&) = delete;
static GC_Singleton* instance;
// 嵌套的垃圾回收类
class GarbageCollector {
public:
~GarbageCollector() {
if (GC_Singleton::instance != nullptr) {
delete GC_Singleton::instance;
GC_Singleton::instance = nullptr;
}
}
};
// 静态垃圾回收实例
static GarbageCollector gc;
public:
static GC_Singleton* getInstance() {
if (instance == nullptr) {
instance = new GC_Singleton();
}
return instance;
}
void run() {
std::cout << "GC_Singleton 运行" << std::endl;
}
};
// 初始化静态成员
GC_Singleton* GC_Singleton::instance = nullptr;
GC_Singleton::GarbageCollector GC_Singleton::gc;
int main() {
GC_Singleton::getInstance()->run();
return 0;
}
不同方案的对比和选择
| 方案 | 优点 | 缺点 | 适用场景 |
|---|---|---|---|
| 静态局部变量实现 | 实现简单，线程安全（C++11后），自动销毁 | 销毁顺序依赖初始化顺序，复杂依赖场景可能出问题 | 单例无复杂依赖，追求简单实现的场景 |
| 智能指针+atexit | 销毁逻辑可控，可灵活处理资源释放 | 实现相对复杂，需要手动注册销毁函数 | 需要自定义销毁逻辑，单例依赖复杂的场景 |
| 嵌套垃圾回收类 | 自动销毁，不需要外部干预 | 代码结构相对复杂，需要额外定义嵌套类 | 需要封装销毁逻辑，不希望暴露销毁接口的场景 |
在实际开发中，如果没有特殊的销毁需求，优先选择静态局部变量的实现方式，既简单又能保证线程安全和自动销毁。如果单例之间存在依赖关系，需要明确销毁顺序，那么可以选择智能指针结合atexit的方案，手动控制销毁的优先级，避免销毁顺序导致的未定义行为。