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

一文带你深入了解懒汉模式和饿汉模式

news 2026/5/12 2:52:21

一文带你深入了解懒汉模式和饿汉模式

文章目录

一文带你深入了解懒汉模式和饿汉模式
- 一、饿汉模式 (Hungry Singleton)
- - 饿汉模式特点
  - 工作原理
- 二、懒汉模式 (Lazy Singleton)
- - 懒汉模式特点
  - 双重检查锁原理
- 三、两种模式对比
- 四、懒汉模式的潜在问题
- - 问题1：内存泄漏
  - 问题2：指令重排风险（C++11之前）
- 五、C++11 后的最佳实践（Meyers' Singleton）
- - 优点：
- 六、单例模式使用场景
- 七、总结
总结

这是一个经典的单例模式实现，包含了饿汉模式和懒汉模式两种版本。你的代码非常完整，我来详细解释这两种模式的原理、优缺点以及你代码中的关键细节。

一、饿汉模式 (Hungry Singleton)

classhunger{public:statichunger*getinstance(){return&_instance;// 直接返回静态对象的地址}private:hunger(){}// 私有构造hunger(consthunger&)=delete;hunger&operator=(consthunger&)=delete;private:statichunger _instance;// 静态成员变量};// 在类外初始化（程序启动时创建）hunger hunger::_instance;

饿汉模式特点

特性	说明
初始化时机	程序启动时（main函数执行前）就创建好实例
线程安全	天然线程安全（初始化在单线程阶段完成）
访问速度	最快（直接返回已存在的对象）
资源占用	无论是否使用，都会占用资源

工作原理

intmain(){// 程序启动时，静态对象 _instance 已经构造完成hunger*p1=hunger::getinstance();hunger*p2=hunger::getinstance();// p1 == p2，同一个实例return0;}

二、懒汉模式 (Lazy Singleton)

classlazy{public:staticlazy*getinstance(){if(_instance==nullptr)// 第一次检查（不用锁）{_mtx.lock();// 加锁if(_instance==nullptr)// 第二次检查（双重检查锁）{_instance=newlazy();}_mtx.unlock();}return_instance;}private:lazy(){}lazy(constlazy&)=delete;lazy&operator=(constlazy&)=delete;private:staticmutex _mtx;// 互斥锁staticlazy*_instance;// 指针};// 初始化lazy*lazy::_instance=nullptr;mutex lazy::_mtx;

懒汉模式特点

特性	说明
初始化时机	第一次调用 getinstance()时才创建
线程安全	需要额外机制保证（你用了双重检查锁）
资源占用	按需创建，节省资源
性能	第一次调用有锁开销，后续无锁

双重检查锁原理

你的代码使用了经典的双重检查锁模式：

if(_instance==nullptr)// 第一重检查：避免每次调用都加锁{_mtx.lock();// 只有第一次才进入锁if(_instance==nullptr)// 第二重检查：防止多个线程同时通过第一重检查{_instance=newlazy();}_mtx.unlock();}

三、两种模式对比

对比维度	饿汉模式	懒汉模式
初始化时机	程序启动时	首次使用时
线程安全	天然安全	需要手动保证
实现复杂度	简单	复杂（需要锁）
启动速度	较慢（要构造单例）	快
运行效率	高（无锁）	高（除第一次外无锁）
内存占用	总是占用	按需占用
适用场景	单例一定会被使用	单例可能不被使用

四、懒汉模式的潜在问题

问题1：内存泄漏

你的代码没有考虑释放单例对象。虽然程序结束时会由操作系统回收，但严格来说应该有释放机制。

// 改进：添加一个嵌套的析构辅助类classlazy{public:staticlazy*getinstance(){...}private:// 辅助析构的内部类classDeleter{public:~Deleter(){if(lazy::_instance){deletelazy::_instance;lazy::_instance=nullptr;}}};staticDeleter _deleter;// 程序结束时自动析构};

问题2：指令重排风险（C++11之前）

_instance=newlazy();// 实际分三步：// 1. 分配内存// 2. 调用构造函数// 3. 赋值给 _instance// 编译器或CPU可能重排为 1->3->2！

C++11 后可以用std::call_once或std::atomic解决：

#include<atomic>#include<mutex>classlazy{public:staticlazy*getinstance(){lazy*tmp=_instance.load(std::memory_order_acquire);if(tmp==nullptr){std::lock_guard<std::mutex>lock(_mtx);tmp=_instance.load(std::memory_order_relaxed);if(tmp==nullptr){tmp=newlazy();_instance.store(tmp,std::memory_order_release);}}returntmp;}private:staticstd::atomic<lazy*>_instance;staticstd::mutex _mtx;};

五、C++11 后的最佳实践（Meyers’ Singleton）

C++11 保证静态局部变量的初始化是线程安全的，所以最简单安全的懒汉模式是：

classSingleton{public:staticSingleton&getInstance(){staticSingleton instance;// 静态局部变量（C++11 线程安全）returninstance;}private:Singleton(){}~Singleton(){}Singleton(constSingleton&)=delete;Singleton&operator=(constSingleton&)=delete;};

优点：

线程安全（C++11 保证）
无锁，性能好
代码极简
自动析构

六、单例模式使用场景

场景	说明
配置管理器	全局唯一的配置对象
日志系统	所有模块写同一个日志文件
线程池	全局唯一的线程池实例
数据库连接池	避免创建多个连接池
文件系统	统一的文件操作接口