【C++】—— 单例模式详解
前言：
- 本期，我将要讲解的是有关C++中常见的设计模式之单例模式的相关知识！！
目录
（一）设计模式的六⼤原则
（二）设计模式的分类
（三）单例模式
1、定义
2、实现方式
1️⃣ 懒汉模式
2️⃣ 饿汉模式
（四）懒汉模式的安全实现
总结
首先我们需要知道的是设计模式是前辈们对代码开发经验的总结，是解决特定问题的⼀系列套路。它不是语法规定，⽽是⼀套⽤来提⾼代码可复⽤性、可维护性、可读性、稳健性以及安全性的解决⽅案。
（一）设计模式的六⼤原则
单⼀职责原则（Single Responsibility Principle）
- 类的职责应该单⼀，⼀个⽅法只做⼀件事。职责划分清晰了，每次改动到最⼩单位的⽅法或类。
- 使用建议：两个完全不⼀样的功能不应该放⼀个类中，⼀个类中应该是⼀组相关性很⾼的函数、数据的封装
- 用例：⽹络聊天：⽹络通信&聊天，应该分割成为⽹络通信类&聊天类
开闭原则（Open Closed Principle）
- 对扩展开放，对修改封闭
- 使用建议：对软件实体的改动，最好⽤扩展⽽⾮修改的⽅式。
- 用例：超时卖货：商品价格---不是修改商品的原来价格，⽽是新增促销价格。
⾥⽒替换原则（Liskov Substitution Principle）
- 通俗点讲，就是只要⽗类能出现的地⽅，⼦类就可以出现，⽽且替换为⼦类也不会产⽣任何错误或异常。
- 在继承类时，务必重写⽗类中所有的⽅法，尤其需要注意⽗类的protected⽅法，⼦类尽量不要暴露⾃⼰的public⽅法供外界调⽤。
- 使用建议：⼦类必须完全实现⽗类的⽅法，孩⼦类可以有⾃⼰的个性。覆盖或实现⽗类的⽅法时，输⼊参数可以被放⼤，输出可以缩⼩
- 用例：跑步运动员类 -- 会跑步，⼦类⻓跑运动员 -- 会跑步且擅⻓⻓跑，⼦类短跑运动员-会跑步且擅⻓短跑
依赖倒置原则（Dependence Inversion Principle）
- ⾼层模块不应该依赖低层模块，两者都应该依赖其抽象。不可分割的原⼦逻辑就是低层模式，原⼦逻辑组装成的就是⾼层模块。
- 模块间依赖通过抽象（接⼝）发⽣，具体类之间不直接依赖
- 使用建议：每个类都尽量有抽象类，任何类都不应该从具体类派⽣。尽量不要重写基类的⽅法。结合⾥⽒替换原则使⽤。
- 用例：奔驰⻋司机类--只能开奔驰；司机类--给什么⻋，就开什么⻋；开⻋的⼈：司机--依赖于抽象
迪⽶特法则（Law of Demeter），⼜叫“最少知道法则”
- 尽量减少对象之间的交互，从⽽减⼩类之间的耦合。⼀个对象应该对其他对象有最少的了解。
- 对类的低耦合提出了明确的要求：只和直接的朋友交流，朋友之间也是有距离的。⾃⼰的就是⾃⼰的（如果⼀个⽅法放在本类中，既不增加类间关系，也对本类不产⽣负⾯影响，那就放置在本类中）
- 用例：⽼师让班⻓点名--⽼师给班⻓⼀个名单，班⻓完成点名勾选，返回结果，⽽不是班⻓点名，⽼师勾选
接⼝隔离原则（Interface Segregation Principle）
- 客⼾端不应该依赖它不需要的接⼝，类间的依赖关系应该建⽴在最⼩的接⼝上
- 使用建议：接⼝设计尽量精简单⼀，但是不要对外暴露没有实际意义的接⼝。
- 用例：修改密码，不应该提供修改⽤⼾信息接⼝，⽽就是单⼀的最⼩修改密码接⼝，更不要暴露数据库操作
从整体上来理解六⼤设计原则，可以简要的概括为⼀句话，⽤抽象构建框架，⽤实现扩展细节，具体到每⼀条设计原则，则对应⼀条注意事项：
- 单⼀职责原则告诉我们实现类要职责单⼀；
- ⾥⽒替换原则告诉我们不要破坏继承体系；
- 依赖倒置原则告诉我们要⾯向接⼝编程；
- 接⼝隔离原则告诉我们在设计接⼝的时候要精简单⼀；
- 迪⽶特法则告诉我们要降低耦合；
- 开闭原则是总纲，告诉我们要对扩展开放，对修改关闭。
（二）设计模式的分类
设计模式可以根据其目的和使用方式进行分类。以下是常见的设计模式分类：
-
创建型模式（Creational Patterns）：这些模式关注对象的创建过程，用于实例化对象的方式。常见的创建型模式包括：
- 单例模式（Singleton Pattern）
- 工厂模式（Factory Pattern）
- 抽象工厂模式（Abstract Factory Pattern）
- 建造者模式（Builder Pattern）
- 原型模式（Prototype Pattern）
-
结构型模式（Structural Patterns）：这些模式关注对象之间的组合和关联方式，以形成更大的结构。常见的结构型模式包括：
- 适配器模式（Adapter Pattern）
- 装饰器模式（Decorator Pattern）
- 代理模式（Proxy Pattern）
- 桥接模式（Bridge Pattern）
- 组合模式（Composite Pattern）
- 外观模式（Facade Pattern）
- 享元模式（Flyweight Pattern）
-
行为型模式（Behavioral Patterns）：这些模式关注对象之间的通信和交互方式，以定义对象之间的责任分配和行为。常见的行为型模式包括：
- 观察者模式（Observer Pattern）
- 策略模式（Strategy Pattern）
- 模板方法模式（Template Method Pattern）
- 命令模式（Command Pattern）
- 迭代器模式（Iterator Pattern）
- 状态模式（State Pattern）
- 职责链模式（Chain of Responsibility Pattern）
- 中介者模式（Mediator Pattern）
- 访问者模式（Visitor Pattern）
- 备忘录模式（Memento Pattern）
- 解释器模式（Interpreter Pattern）
除了这些主要的分类，其实还有：并发模式和线程池模式。
（三）单例模式
本期，我们先学习设计模式中的第一种模式——单例模式。
1、定义
⼀个类只能创建⼀个对象，即单例模式，该设计模式可以保证系统中该类只有⼀个实例，并提供⼀个访问它的全局访问点，该实例被所有程序模块共享。⽐如在某个服务器程序中，该服务器的配置信息存放在⼀个⽂件中，这些配置数据由⼀个单例对象统⼀读取，然后服务进程中的其他对象再通过这个单例对象获取这些配置信息，这种⽅式简化了在复杂环境下的配置管理。
2、实现方式
单例模式通常有两种模式，分别为懒汉式单例和饿汉式单例。两种模式实现方式分别如下：
1️⃣ 懒汉模式
如果单例对象构造十分耗时或者占用很多资源，比如加载插件啊， 初始化网络连接啊，读取文件啊等等，而有可能该对象程序运行时不会用到，那么也要在程序一开始就进行初始化，就会导致程序启动时非常的缓慢。 所以这种情况使用懒汉模式（延迟加载）更好！！
对于懒汉模式常见的有两种设计方法：
- a. 静态指针 + 用到时初始化
- b. 局部静态变量
（1）懒汉模式实现一：静态指针 + 用到时初始化
template
class Singleton
{
public:
static T& getInstance()
{
if (!_value)
{
_value = new T();
}
return *_value;
}
private:
Singleton()
{}
~Singleton()
{}
static T* _value;
};
template
T* Singleton::_value = NULL; 【解释说明】
在单线程中，这样的写法是可以正确使用的，但是在多线程中就不行了，该方法是线程不安全的。
- a. 假如线程A和线程B, 这两个线程要访问getInstance函数，线程A进入getInstance函数，并检测if条件，由于是第一次进入，value为空，if条件成立，准备创建对象实例。
- b. 但是，线程A有可能被OS的调度器中断而挂起睡眠，而将控制权交给线程B。
- c. 线程B同样来到if条件，发现value还是为NULL，因为线程A还没来得及构造它就已经被中断了。此时假设线程B完成了对象的创建，并顺利的返回。
- d. 之后线程A被唤醒，继续执行new再次创建对象，这样一来，两个线程就构建两个对象实例，这就破坏了唯一性
另外，还存在内存泄漏的问题，new出来的东西始终没有释放，下面是一种饿汉式的一种改进。
template
class Singleton
{
public:
static T& getInstance()
{
if (!_value)
{
_value = new T();
}
return *_value;
}
private:
// 实现一个内嵌垃圾回收类
class CGarbo
{
public:
~CGarbo()
{
if (Singleton::_value)
delete Singleton::_value;
}
};
static CGarbo Garbo;
Singleton()
{};
~Singleton()
{};
static T* _value;
};
template
T* Singleton::_value = nullptr; 【解释说明】
- 在程序运行结束时，系统会调用 Singleton 的静态成员Garbo的析构函数，该析构函数会删除单例的唯一实例。
使用这种方法释放单例对象有以下特征：
- 在单例类内部定义专有的嵌套类
- 在单例类内定义私有的专门用于释放的静态成员；
- 利用程序在结束时析构全局变量的特性，选择最终的释放时机
【注意】
- 需要注意的是，该代码在多线程环境下并不是线程安全的；
- 如果多个线程同时用
getInstance()，有可能会创建多个对象。为了实现线程安全的单例模式，需要使用适当的同步机制，例如使用互斥锁或双重检查锁定（这个下面会讲到）
（2）懒汉模式实现二：局部静态变量
template
class Singleton {
public:
static T& getInstance() {
static T instance;
return instance;
}
private:
Singleton() {}
~Singleton() {}
Singleton(const Singleton&);
Singleton& operator=(const Singleton&);
}; 【解释说明】
- 在上述代码中将拷贝构造函数和赋值操作符的声明放在了私有部分，但没有给它们提供定义。这样，任何尝试在类外部调用这些函数的操作都会导致链接错误。这种方式达到了限制拷贝的目的，确保单例对象的唯一性。
- 使用此模式时，通过
Singleton调用::getInstance() getInstance()函数来获取到YourClass类的单例对象。 - 这种实现方式也是一种常见的懒汉模式实现方法，不需要使用
delete关键字，而是通过私有化拷贝构造函数和赋值操作符来限制拷贝行为，从而实现单例的唯一性。
2️⃣ 饿汉模式
程序启动时就会创建⼀个唯⼀的实例对象。因为单例对象已经确定，所以⽐较适⽤于多
线程环境中，多线程获取单例对象不需要加锁，可以有效的避免资源竞争，提⾼性能。
（1）饿汉模式实现一：直接定义静态对象
template
class Singleton
{
private:
static T _eton;
private:
Singleton() {}
~Singleton() {}
public:
Singleton(const Singleton&) = delete;
Singleton& operator=(const Singleton&) = delete;
static T& getInstance()
{
return _eton;
}
};
template
T Singleton::_eton; 优点：
- 实现简单，多线程安全。
缺点：
- a. 如果存在多个单例对象且这几个单例对象相互依赖，可能会出现程序崩溃的危险。原因:对编译器来说，静态成员变量的初始化顺序和析构顺序是一个未定义的行为;
- b. 在程序开始时，就创建类的实例，如果Singleton对象产生很昂贵，而本身有很少使用，这种方式单从资源利用效率的角度来讲，比懒汉式单例类稍差些。但从反应时间角度来讲，则比懒汉式单例类稍好些。
使用条件：
- a. 当肯定不会有构造和析构依赖关系的情况。
- b. 想避免频繁加锁时的性能消耗
（2）饿汉模式实现二：静态指针 + 类外初始化时new空间实现
template
class Singleton
{
private:
static T* _eton;
Singleton() {}
~Singleton() {}
public:
Singleton(const Singleton&) = delete;
Singleton& operator=(const Singleton&) = delete;
static T& getInstance()
{
return *_eton;
}
};
template
T* Singleton::_eton = new T(); 【小结】
- 需要注意的是，由于饿汉模式在程序启动时就创建了单例对象，因此无法实现延迟加载的效果；
- 如果在程序运行过程中不一定需要使用该单例对象，会导致不必要的资源消耗；
- 因此，懒汉模式通常更常用，只在需要时才创建单例对象。
（四）懒汉模式的安全实现
class Singleton
{
public:
static Singleton* GetInstance()
{
// 双检查加锁
if (m_pInstance == nullptr) {
m_mutex.lock();
if (m_pInstance == nullptr)
{
m_pInstance = new Singleton;
}
m_mutex.unlock();
}
return m_pInstance;
}
static void DelInstance()
{
m_mutex.lock();
if (m_pInstance)
{
delete m_pInstance;
m_pInstance = nullptr;
}
m_mutex.unlock();
}
// 实现一个内嵌垃圾回收类
class CGarbo
{
public:
~CGarbo()
{
DelInstance();
}
};
// 定义一个静态成员变量，程序结束时，系统会自动调用它的析构函数从而释放单例对象
static CGarbo Garbo;
// 一般全局都要使用单例对象，所以单例对象一般不需要显示释放
// 有些特殊场景，想显示释放一下
void Add(const string& str)
{
_vmtx.lock();
_v.push_back(str);
_vmtx.unlock();
}
void Print()
{
_vmtx.lock();
for (auto& e : _v)
{
cout << e << endl;
}
cout << endl;
_vmtx.unlock();
}
~Singleton()
{
// 持久化
// 比如要求程序结束时，将数据写到文件，单例对象析构时持久化就比较好
}
private:
mutex _vmtx;
vector _v;
private:
// 构造函数私有
Singleton()
{}
// 防拷贝
//Singleton(Singleton const&);
//Singleton& operator = (Singleton const&);
static mutex m_mutex; //互斥锁
static Singleton* m_pInstance; // 单例对象指针
};
Singleton* Singleton::m_pInstance = nullptr;
Singleton::CGarbo Garbo;
mutex Singleton::m_mutex;
int main()
{
srand(time(0));
int n = 3000;
thread t1([n]() {
for (size_t i = 0; i < n; ++i)
{
Singleton::GetInstance()->Add("t1线程:" + to_string(rand()));
}
});
thread t2([n]() {
for (size_t i = 0; i < n; ++i)
{
Singleton::GetInstance()->Add("t2线程:" + to_string(rand()));
}
});
t1.join();
t2.join();
Singleton::GetInstance()->Print();
return 0;
} 总结
到此，关于单例模式的讲解便到此结束了。接下来，简单的回顾总结一下本文！！！
懒汉模式和饿汉模式都是单例模式的实现方式，都用于确保一个类只有一个实例，并提供全局访问点。
- 懒汉模式：是指在首次使用时才创建对象实例。具体实现上，懒汉模式通常通过延迟加载的方式，在getInstance()方法中进行判断，如果实例尚未创建，则在需要时才创建并返回。懒汉模式的优点是节省了资源，只有在需要时才会创建实例，但缺点是在多线程环境下需要额外的同步机制，以确保线程安全。
- 饿汉模式：是指在类加载时即创建对象实例。具体实现上，饿汉模式通过在类的静态成员变量中直接创建实例对象，并在getInstance()方法中返回该实例。饿汉模式的优点是实现简单，不需要考虑多线程同步的问题，但缺点是在应用程序启动时就会创建实例，可能会浪费一些资源。
在实际应用中根据具体情况权衡懒汉模式和饿汉模式的优缺点，并选择适合的实现方式。
以上便是本文的全部内容，感谢大家的观看和支持！！！