C++设计模式——Singleton单例模式
一、单例模式的定义
单例模式，英文全称Singleton Pattern，是一种创建型设计模式，它保证一个类在程序中仅有一个实例，并对外提供一个访问的该类实例的全局接口。
单例模式通常用于需要控制对象资源的开发场景，一个类只创建一个对象的设计，既可以避免创建过多副本所造成的资源浪费现象，又可以避免引发数据一致性等问题。
在数据库连接、线程池设计、日志系统设计等开发场景，经常使用单例模式来创建对象，可以有效地降低对内存资源的占用。
在编码时，为了防止外部直接通过new关键字创建对象实例，Singleton类的构造函数必须是私有的。
在多线程开发场景，单例模式可以避免多个线程同时访问同一个资源，从而避免资源竞争的问题，如果还需要进一步保证线程安全性，可以在创建实例时添加同步锁。
单例模式在现实生活中的抽象实例：
电力公司：在一个城市或地区，通常只有一个电力公司负责供电，我们可以通过该公司来获取电力服务。
总统办公室：在一个国家，通常只有一个总统办公室负责国家事务处理，办公室负责确保国家事务的一致性和高效运作。
登录系统：用户只需要登录一次就可以打开多个应用程序的界面。
二、单例模式的结构
单例模式主要包含以下组件：
1.Singleton类：这是一个单例类，它在整个系统中只有一个实例。通常使用私有构造函数来创建、使用公共静态成员方法来访问。
2.私有构造函数：为了避免被外部实例化，Singleton类通常会定义一个私有构造函数，使得其他类无法通过调用构造函数创建Singleton的实例对象。
3.私有静态成员变量：Singleton类通常会声明一个私有静态成员变量，用来保存Singleton的唯一实例，且这个静态变量只能在Singleton类内部访问。
4.公共的对外接口：它通常被命名为getInstance()，通过该接口可以获取Singleton的唯一实例对象。该接口使用懒汉/饿汉的方式来实现，在接口内部会先判断实例是否已经存在，如果存在则直接返回，否则创建一个新的实例并返回。
组件之间的工作步骤如下：
1.饿汉模式的程序启动：在程序启动的同时就创建好Singleton实例，并提供全局唯一的外部访问接口，外部程序可以直接调用该接口来获取Singleton实例。
2.懒汉模式的程序启动：程序启动时并不会创建Singleton实例，程序在等到单例对象被第一次使用时才创建Singleton实例。
3.采用私有的静态变量存储已经创建好的Singleton实例。
4.外部客户端通过唯一的外部访问接口来访问并使用Singleton实例。
饿汉模式单例 & 懒汉模式单例：
饿汉模式(Singleton with Instantiation)：
是一种线程安全的实现方法，在类初始化时就完成了单例实例的创建。
懒汉模式(Singleton with Lazy Initialization)：
也被称为"双检锁"模式，只有当第一次真正需要获取单例实例时才进行单例实例的创建。
饿汉模式和懒汉模式都实现了单例，即保证在整个应用程序的生命周期中只有一个Singleton类实例。
饿汉模式的优点是线程安全，但缺点是如果该实例很复杂会增加初始化的耗时，从而导致程序的启动时间被延长。
懒汉模式的优点是延迟加载，可以节约资源和减少程序的启动耗时，缺点是需要考虑多线程环境下创建对象导致的线程安全问题，它通常在外部访问接口中使用双重检查锁定(Double-checked locking)来保证线程安全。
对应UML类图：
三、单例模式代码样例
1.单例模式的伪代码：
#include <iostream>
class Singleton {
private:
static Singleton* instance;
//私有构造函数，确保不能从外部实例化对象
Singleton() {}
public:
//获取单例实例的静态方法
static Singleton* getInstance() {
if (instance == nullptr) {
instance = new Singleton();
}
return instance;
}
};
Singleton* Singleton::instance = nullptr;
int main() {
Singleton* singleton = Singleton::getInstance();
return 0;
}
2.单例模式的加锁版伪代码：
class Singleton {
private:
static Singleton* instance;
Singleton() {} //私有化构造函数，防止外部创建实例
public:
static Singleton* getInstance() {
if (instance == nullptr) {
//在多线程环境下需要加锁保证只创建一个实例
// std::lock_guard<std::mutex> lock(mutex);
instance = new Singleton();
}
return instance;
}
//单例类的其他成员函数
void doSomething() {
// ...
}
};
Singleton* Singleton::instance = nullptr;
int main() {
Singleton* obj1 = Singleton::getInstance();
obj1->doSomething();
Singleton* obj2 = Singleton::getInstance();
obj2->doSomething();
delete obj1; //释放资源
return 0;
}3.饿汉模式的伪代码：
class Singleton {
private:
static Singleton* instance;
//私有构造函数，防止外部直接创建对象
Singleton() {}
public:
//静态成员函数，用于获取单例对象
static Singleton* getInstance() {
return instance;
}
};
//提前创建好单例对象
Singleton* Singleton::instance = new Singleton();4.懒汉模式的伪代码：
class Singleton {
private:
static Singleton* instance;
Singleton() {}
public:
//使用时才创建单例对象
static Singleton* getInstance() {
if (instance == nullptr) {
instance = new Singleton();
}
return instance;
}
};Demo1：完整代码实现
#include <iostream>
class Singleton {
private:
static Singleton* instance;
Singleton() {}
public:
static Singleton* getInstance() {
if (instance == nullptr) {
instance = new Singleton();
}
return instance;
}
void showMessage() {
std::cout << "Hello, World!" << std::endl;
}
};
Singleton* Singleton::instance = nullptr;
int main() {
// 获取Singleton对象实例
Singleton* singleton = Singleton::getInstance();
// 调用对象的方法
singleton->showMessage();
return 0;
}运行结果：
Hello, World!Demo2：增加析构函数
#include <iostream>
class Singleton {
public:
static Singleton& getInstance()
{
//如果对象实例不存在就创建一个
if (!instance) {
instance = new Singleton();
}
return *instance;
}
//给外部调用的接口
void Operation()
{
std::cout
<< "Singleton is performing some operation."
<< std::endl;
}
Singleton(const Singleton&) = delete;
Singleton& operator=(const Singleton&) = delete;
private:
//私有化的构造函数
Singleton()
{
std::cout << "Singleton instance created."
<< std::endl;
}
//私有化的析构函数
~Singleton()
{
std::cout << "Singleton instance destroyed."
<< std::endl;
}
static Singleton* instance;
};
Singleton* Singleton::instance = nullptr;
int main()
{
Singleton& singleton = Singleton::getInstance();
singleton.Operation();
return 0;
}运行结果：
Singleton instance created.
Singleton is performing some operation.四、单例模式的优缺点
单例模式的优点：
可以有效限制资源的数量，对于那些需要全局访问的资源，单例模式可以保证该资源只有一个实例。
对象的创建/销毁过程最多只有一次，可以节省系统开销。
可以统一管理全局配置，如果单例模式的对象用来存储一些配置信息，可以实现对全局配置的管理。
简化了访问资源的入口，由于全局只有一个实例，使得客户端只需要关注一个访问入口即可。
单例模式的缺点：
缺乏灵活性，一旦创建了单例对象，就不能更改其实例化过程。
限制了一个类只能有一个实例，难以扩展该类的功能。
由于单例对象是全局可访问的，可能引发全局变量的滥用。
存在线程安全隐患，如果不增加一些锁机制，在多线程环境下可能会创建多个实例，影响单例的特性。
五、代码实战
#include <iostream>
using namespace std;
class Singleton
{
private:
static bool instanceFlag;
static Singleton* single;
Singleton()
{
printf("Private constructor finished.\n");
}
public:
static Singleton* getInstance();
void method();
~Singleton()
{
printf("Public de-constructor finished.\n");
instanceFlag = false;
}
};
bool Singleton::instanceFlag = false;
Singleton* Singleton::single = NULL;
Singleton* Singleton::getInstance()
{
if (!instanceFlag)
{
single = new Singleton();
instanceFlag = true;
return single;
}
else
{
return single;
}
}
void Singleton::method()
{
cout << "Method of the singleton class" << endl;
}
int main()
{
Singleton* sc1, * sc2;
sc1 = Singleton::getInstance();
sc1->method();
sc2 = Singleton::getInstance();
sc2->method();
delete sc1, sc2;
return 0;
}运行结果：
Private constructor finished.
Method of the singleton class
Method of the singleton class
Public de-constructor finished.六、参考阅读
https://www.geeksforgeeks.org/singleton-pattern-c-design-patterns/
https://scottlilly.com/c-design-patterns-the-singleton-pattern/
https://www.tutorialspoint.com/explain-cplusplus-singleton-design-pattern
https://www.codeproject.com/Articles/1921/Singleton-Pattern-its-implementation-with-Cplusplu