阅读导航
- 引言
- 一、设计模式概念（了解）
- 二、单例模式
- 1. 饿汉模式
- （1）概念
- （2）模拟实现
- （3）优缺点
- （4）适用场景
- 2. 懒汉模式
- （1）概念
- （2）模拟实现
- 🚩思路一（双检查加锁，常规思路）
- 🚩思路二（使用静态局部变量的方式来实现单例模式）
- （3）优缺点
- （4）适用场景
- 温馨提示
引言
在面向对象编程中，特殊类是指具有特定属性或限制的类，这些属性或限制使其在设计和使用上与常规类不同。在上一篇文章中，我们讨论了一些特殊类，如只能在堆上创建对象的类、只能在栈上创建对象的类以及禁止拷贝和继承的类。
在本文中，我们将继续探讨特殊类的设计，着重介绍单例模式。单例模式是一种常见的设计模式，它确保一个类只有一个实例，并提供了全局访问点。在许多情况下，我们需要确保只有一个对象来协调系统操作或管理共享资源，而单例模式正是解决这类问题的理想选择。
本文将深入研究单例模式的原理和实现方式。我们将介绍几种常见的单例模式实现方法，包括饿汉式、懒汉式、双重检查锁定和静态内部类。我们将详细讨论每种实现方法的优缺点，并提供相应的示例代码。让我们一起探索单例模式的精髓吧！
一、设计模式概念（了解）
设计模式是一种被广泛接受和应用的软件开发经验总结，它提供了解决常见问题的可重用方案。设计模式帮助开发人员以一种可靠、灵活和可维护的方式构建软件系统。
设计模式的概念最早由计算机科学家埃里希·伽玛（Erich Gamma）等人在1994年的著作《设计模式：可复用面向对象软件的基础》中引入。该书提出了23种经典的设计模式，这些模式分为三大类：创建型模式、结构型模式和行为型模式。
每种设计模式都有其特定的应用场景和解决方案，开发人员可以根据具体需求选择适当的模式来解决问题。设计模式不仅提供了一种通用的解决方案，还促进了代码的可读性、可维护性和可扩展性。
然而，设计模式并非万能药，过度使用或错误使用设计模式可能导致代码变得复杂和难以理解。因此，在应用设计模式时，开发人员需要谨慎权衡，并结合实际情况做出决策。
总之，设计模式是一种帮助开发人员解决常见问题的工具，它提供了一套经过验证的解决方案。通过学习和应用设计模式，开发人员可以提高软件系统的质量和可维护性，从而更加高效地开发出优秀的软件。使用设计模式的目的：为了代码可重用性、让代码更容易被他人理解、保证代码可靠性。 设计模式使代码编写真正工程化；设计模式是软件工程的基石脉络，如同大厦的结构一样。
二、单例模式
一个类只能创建一个对象，即单例模式，该模式可以保证系统中该类只有一个实例，并提供一个访问它的全局访问点，该实例被所有程序模块共享。比如在某个服务器程序中，该服务器的配置信息存放在一个文件中，这些配置数据由一个单例对象统一读取，然后服务进程中的其他对象再通过这个单例对象获取这些配置信息，这种方式简化了在复杂环境下的配置管理。
⭕单例模式有两种实现模式：饿汉模式 和 懒汉模式，下面我会一个一个的向大家介绍
1. 饿汉模式
（1）概念
饿汉模式是单例模式的一种实现方式，它在类加载时就创建唯一的实例对象，并通过静态方法提供全局访问点。简单来说就是不管你将来用不用，程序启动时就创建一个唯一的实例对象。
🍪特点：
- 在类加载时就创建实例对象，因此可以保证实例的唯一性。
- 通过静态方法提供全局访问点，方便其他代码获取该实例。
- 线程安全，由于在类加载时创建实例，因此不需要考虑多线程并发访问的问题。
（2）模拟实现
// 饿汉模式：一开始(main函数之前)就创建对象
class Singleton
{
public:
// 静态方法，返回唯一实例对象的地址
static Singleton* GetInstance()
{
return _ins;
}
// 向字符串向量中添加元素，保证线程安全
void Add(const string& str)
{
_mtx.lock(); // 获取互斥锁
_v.push_back(str); // 执行操作
_mtx.unlock(); // 释放互斥锁
}
// 打印字符串向量中的所有元素，保证线程安全
void Print()
{
_mtx.lock(); // 获取互斥锁
for (auto& e : _v)
{
cout << e << endl;
}
cout << endl;
_mtx.unlock(); // 释放互斥锁
}
private:
// 构造函数私有化，禁止外部创建对象
Singleton()
{}
// 防拷贝构造和赋值运算符，保证实例的唯一性
Singleton(const Singleton& s) = delete;
Singleton& operator=(const Singleton& s) = delete;
private:
mutex _mtx; // 互斥锁，保证线程安全
vector<string> _v; // 字符串向量，存储数据
static Singleton* _ins; // 唯一实例对象的地址
};
// 初始化静态成员变量
Singleton* Singleton::_ins = new Singleton();
以上代码实现了一个简单的使用饿汉模式实现的线程安全的单例类。它在类加载时就创建了唯一的实例对象，并提供了全局访问点，适用于需要在整个应用程序中共享一个实例对象的场景。同时，该类的实现还保证了多线程并发访问时的线程安全性，避免了数据竞争和死锁等问题。
（3）优缺点
-
优点
- 实现简单直观，代码易于理解。
- 线程安全，不需要额外的同步处理，适合在多线程环境中使用。
- 对象的创建是在类加载时完成的，可以避免线程安全问题和延迟加载的复杂性。
-
缺点
- 在程序运行期间始终存在实例对象，可能会造成资源浪费。
- 如果该实例对象的创建过程耗时较长，会导致应用程序启动变慢。
- 不支持延迟加载，无法根据实际需要来创建实例。
（4）适用场景
- 对象的创建过程简单且耗时较短的情况，适合使用饿汉模式。
- 需要在整个应用程序中共享一个实例对象的情况，适合使用饿汉模式。
- 在多线程环境下需要保证实例的唯一性和线程安全的情况，适合使用饿汉模式。
总的来说：饿汉模式是一种简单有效的单例模式实现方式，适合于对象创建耗时较短、且需要全局访问的情况。但在实际应用中，需要根据具体需求和性能要求选择适当的单例模式实现方式。
2. 懒汉模式
（1）概念
懒汉模式是指在需要时才创建实例对象的单例模式。在懒汉模式中，实例对象的创建被延迟到第一次使用时，而不是在程序启动时就立即创建。这样可以避免在程序启动时创建不必要的实例对象，节省系统资源。
如果单例对象的构造过程耗时且资源占用较多，例如加载插件、初始化网络连接或读取文件等操作，同时在程序运行过程中可能并不经常使用该对象，那么在程序启动时立即进行初始化会导致启动速度缓慢。因此，在这种情况下，采用懒汉模式（延迟加载）是更好的选择。
⭕懒汉模式允许在需要使用该对象时才创建实例，避免了不必要的资源浪费，提高了程序性能。通过懒汉模式，可以延迟加载单例对象，无需在程序启动时进行初始化，从而避免了启动时的缓慢问题。
（2）模拟实现
🚩思路一（双检查加锁，常规思路）
class Singleton
{
public:
static Singleton* GetInstance()
{
// 双检查加锁，提高效率
if (_ins == nullptr) // 第一次检查
{
_imtx.lock(); // 加锁
if (_ins == nullptr) // 第二次检查，确保线程安全
{
_ins = new Singleton; // 创建单例对象
}
_imtx.unlock(); // 解锁
}
return _ins;
}
// 显示释放单例对象
static void DelInstance()
{
_imtx.lock(); // 加锁
if (_ins)
{
delete _ins; // 释放单例对象
_ins = nullptr; // 将指针置为空
}
_imtx.unlock(); // 解锁
}
// 内部类：用于单例对象的资源回收和持久化
class GC
{
public:
~GC()
{
DelInstance(); // 调用DelInstance()函数进行资源回收和持久化
}
};
// 内部静态成员变量，用于实现单例模式
static Singleton* _ins;
static mutex _imtx; // 互斥锁，保证线程安全
// 添加数据到vector中
void Add(const string& str)
{
_vmtx.lock(); // 加锁
_v.push_back(str); // 添加数据到vector中
_vmtx.unlock(); // 解锁
}
// 输出vector中的数据
void Print()
{
_vmtx.lock(); // 加锁
for (auto& e : _v)
{
cout << e << endl; // 输出vector中的数据
}
cout << endl;
_vmtx.unlock(); // 解锁
}
// 析构函数，用于实现单例对象的持久化
~Singleton()
{
// 比如要求程序结束时，将数据写到文件，单例对象析构时持久化就比较好
}
private:
// 私有构造函数，限制类外部创建对象
Singleton()
{}
// 防拷贝
Singleton(const Singleton& s) = delete;
Singleton& operator=(const Singleton& s) = delete;
mutex _vmtx; // 互斥锁，保证线程安全
vector<string> _v; // 存储数据的vector
static GC _gc; // 内部类对象，用于单例对象析构时进行资源回收和持久化
};
// 初始化静态成员变量
Singleton* Singleton::_ins = nullptr;
mutex Singleton::_imtx;
Singleton::GC Singleton::_gc;
🚩思路二（使用静态局部变量的方式来实现单例模式）
class Singleton
{
public:
// 获取单例对象的接口函数
static Singleton* GetInstance()
{
// 使用静态局部变量实现单例模式，保证线程安全
// C++11之前，这里不能保证初始化静态对象的线程安全问题
// C++11之后，这里可以保证初始化静态对象的线程安全问题
static Singleton inst;
return &inst;
}
// 添加数据到vector中
void Add(const string& str)
{
// 加锁，保证线程安全
_vmtx.lock();
// 添加数据到vector中
_v.push_back(str);
// 解锁，保证线程安全
_vmtx.unlock();
}
// 输出vector中的数据
void Print()
{
// 加锁，保证线程安全
_vmtx.lock();
// 遍历vector，输出其中的元素
for (auto& e : _v)
{
cout << e << endl;
}
cout << endl;
// 解锁，保证线程安全
_vmtx.unlock();
}
// 析构函数，用于实现单例对象的持久化
~Singleton()
{
// 比如要求程序结束时，将数据写到文件，单例对象析构时持久化就比较好
}
private:
// 私有构造函数，限制类外部创建对象
Singleton()
{
cout << "Singleton()" << endl;
}
// 防拷贝
Singleton(const Singleton& s) = delete;
Singleton& operator=(const Singleton& s) = delete;
private:
mutex _vmtx; // 互斥锁，保证线程安全
vector<string> _v; // 存储数据的vector
};
这段代码是使用静态局部变量的方式来实现单例模式。
🚨🚨注意：在 C++11 之前，使用静态局部变量的方式需要注意线程安全问题，因为静态局部变量的初始化只会在第一次调用时进行，如果有多个线程同时调用，可能会导致不同步的问题。但在 C++11 之后，静态局部变量的初始化是线程安全的，因此可以放心使用。
（3）优缺点
-
优点
- 延迟加载：懒汉模式在需要时才创建实例对象，避免了在程序启动时的资源浪费。这对于资源消耗较大的对象特别有用。
- 节省系统资源：由于实例对象的创建被延迟到需要时，懒汉模式可以节省系统资源，提高程序的性能。
- 线程安全：通过双重判断锁机制，懒汉模式可以在多线程环境下保证线程安全性。
-
缺点：
- 复杂性增加：相比饿汉模式，懒汉模式的实现相对复杂，需要考虑线程安全性问题。
- 性能损耗：在多线程环境下，由于需要进行双重判断锁机制，可能会导致一定的性能损耗。
（4）适用场景
- 对象创建耗时较长或占用较多资源：懒汉模式可以避免在程序启动时创建不必要的实例对象，节省系统资源。
- 需要延迟加载的场景：如果单例对象在程序运行的早期并不会被频繁使用，而只有在特定条件下才会被需要，那么懒汉模式是一个合适的选择。
- 多线程环境下需要保证线程安全性：通过双重判断锁机制，懒汉模式可以在多线程环境下保证线程安全性，避免多个线程同时创建多个实例对象。
温馨提示
感谢您对博主文章的关注与支持！另外，我计划在未来的更新中持续探讨与本文相关的内容，会为您带来更多关于C++以及编程技术问题的深入解析、应用案例和趣味玩法等。请继续关注博主的更新，不要错过任何精彩内容！
再次感谢您的支持和关注。期待与您建立更紧密的互动，共同探索C++、算法和编程的奥秘。祝您生活愉快，排便顺畅！
