当前位置：首页 > news >正文

「软件设计模式」单例模式

news 2025/2/16 0:36:17

深入解析单例模式：从思想到C++实战实现

一、设计模式与单例模式思想

1.1 设计模式的价值

设计模式是软件工程领域的经验结晶，如同建筑领域的经典蓝图。它们提供了经过验证的解决方案模板，能有效解决以下问题：

提高代码复用性
提升系统可维护性
增强代码可读性
降低模块耦合度

1.2 单例模式核心思想

单例模式（Singleton Pattern）确保一个类：

仅有一个实例存在
提供全局访问点
严格控制实例化过程

适用场景包括：

配置管理器
日志记录器
线程池
数据库连接池
硬件接口访问

二、C++实现方案对比

2.1 基础懒汉式（线程不安全）

#include <iostream>
using namespace std;
// 基础懒汉模式，非线程安全
class Singleton {
public:static Singleton* getInstance() {if (!instance) {instance = new Singleton();}return instance;}void doSomething() {cout << "Doing something..." << endl;}// 删除拷贝构造函数和赋值运算符Singleton(const Singleton&) = delete;Singleton& operator=(const Singleton&) = delete;private:Singleton() = default;~Singleton() = default;static Singleton* instance;
};// 初始化静态成员
Singleton* Singleton::instance = nullptr;#include <thread>
#include <vector>void threadFunction(int i) {Singleton* singleton = Singleton::getInstance();cout << "Thread " << i << " Singleton address: " << singleton << endl;singleton->doSomething();
}int main() {const int numThreads = 10;std::vector<std::thread> threads;for (int i = 0; i < numThreads; ++i) {threads.emplace_back(threadFunction, i);}for (auto& thread : threads) {thread.join();}return 0;
}

运行结果：可以看出非线程安全的，创建了两个实例。

2.2 线程安全双检锁（C++11+）

#include <iostream>
#include <mutex>
#include <thread>
#include <vector>using namespace std;
class ThreadSafeSingleton {
public:static ThreadSafeSingleton* getInstance() {if (!instance) {std::lock_guard<std::mutex> lock(mutex);if (!instance) {instance = new ThreadSafeSingleton();}}return instance;}void doSomething() {cout << "Doing something..." << endl;}private:static ThreadSafeSingleton* instance;static std::mutex mutex;
};// 初始化静态成员
ThreadSafeSingleton* ThreadSafeSingleton::instance = nullptr;
std::mutex ThreadSafeSingleton::mutex;

#include <thread>
#include <vector>
#include "lazy_single_thread_safe.h"void LazySafeThreadFunction(int i) {ThreadSafeSingleton* singleton = ThreadSafeSingleton::getInstance();cout << "Thread Safe" << i << " Singleton address: " << singleton << endl;singleton->doSomething();
}// 线程安全懒汉模式 demo
int main() {const int numThreads = 10;std::vector<std::thread> threads1;for (int i = 0; i < numThreads; ++i) {threads1.emplace_back(LazySafeThreadFunction, i);}for (auto& thread : threads1) {thread.join();}return 0;
}

运行结果：线程安全。

2.3 现代C++实现（最优方案）


#include <iostream>
using namespace std;/****  饿汉式是否 Lazy 初始化：否是否多线程安全：是描述：这种方式比较常用，但容易产生垃圾对象。优点：没有加锁，执行效率会提高。缺点：类加载时就初始化，浪费内存。它基于 classloader 机制避免了多线程的同步问题，不过，instance在类装载时就实例化，虽然导致类装载的原因有很多种，在单例模式中大多数都是调用 getInstance 方法，但是也不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化 instance 显然没有达到 lazy loading 的效果。
*/
#include <iostream>class EagerSingleton {
public:// 获取单例实例的静态方法static EagerSingleton* getInstance() {static EagerSingleton instance; // 在第一次调用时创建实例return &instance;}// 删除拷贝构造函数和赋值运算符，防止复制EagerSingleton(const EagerSingleton&) = delete;EagerSingleton& operator=(const EagerSingleton&) = delete;// 示例方法void doSomething() {cout << "Doing something..." << endl;}private:// 私有构造函数，防止外部实例化EagerSingleton() {std::cout << "EagerSingleton instance created." << std::endl;}
};

运行结果：

方案对比表：

特性	基础懒汉式	双检锁	现代实现
线程安全	❌	✔️	✔️
延迟初始化	✔️	✔️	✔️
自动析构	❌	❌	✔️
C++标准要求	-	≥11	≥11
实现复杂度	简单	中等	简单

三、关键实现细节解析

3.1 线程安全保证

现代实现方案利用C++11的静态变量初始化特性
编译器保证静态局部变量的线程安全
双检锁方案需要内存屏障支持

3.2 资源管理

现代方案自动处理析构
指针方案需要自定义销毁逻辑
可结合智能指针优化：

#include <memory>class SmartSingleton {
public:static SmartSingleton& getInstance() {static auto instance = std::make_shared<SmartSingleton>();return *instance;}// ...其他成员...
};

3.3 继承扩展方案

template <typename T>
class InheritableSingleton {
public:static T& getInstance() {static T instance;return instance;}protected:InheritableSingleton() = default;virtual ~InheritableSingleton() = default;
};class MyLogger : public InheritableSingleton<MyLogger> {friend class InheritableSingleton<MyLogger>;// 具体实现...
};