C++之单例模式

已于 2024-01-10 09:54:40 修改
阅读量1.2k 收藏 21
点赞数 16
分类专栏： c++ 文章标签： c++ 单例模式
于 2024-01-08 14:46:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Zander0/article/details/135454860
版权

C++之单例模式

前言

单例模式（Singleton Pattern）是 面向对象中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

单例模式是一种创建型设计模式，它确保一个类只有一个实例，并提供了一个全局访问点来访问该实例。

优点：通过单例模式的设计，使得创建的类在当前进程中只有一个实例，并提供一个全局性的访问点，这样可以规避因频繁创建对象而导致的 内存飙升 情况。

介绍

意图：保证一个类仅有一个实例，并提供一个访问它的全局访问点。

主要解决：一个全局使用的类频繁地创建与销毁。

何时使用：当您想控制实例数目，节省系统资源的时候。

如何解决：判断系统是否已经有这个单例，如果有则返回，如果没有则创建。

关键代码：构造函数是私有的。

优点：

1、在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例（比如管理学院首页页面缓存）。
2、避免对资源的多重占用（比如写文件操作）。
缺点：没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。

1、单例模式是什么？

在面向对象编程中，有时候我们希望一个类只有一个实例化的对象，比如线程池，缓存等。这些类有且只有一个唯一的实例，这种设计模式被称为单例模式。

1.1 实现单例模式的三个要点

1）私有化构造函数：这样外界就无法自由地创建类对象，进而阻止了多个实例的产生。
2）类定义中含有该类的唯一静态私有对象：静态变量存放在全局存储区，且是唯一的，供所有对象使用。
3）用公有的静态函数来获取该实例：提供了访问接口。

1.2 单例模式分类

单例模式有两种主要实现方法：懒汉模式和饿汉模式。

  1. 懒汉模式特点是当外界调用时才进行实例化；
  2. 饿汉模式特点是一开始就对实例进行初始化，调用时直接返回这个构建好的实例。

2. 懒汉式

懒汉模式特点是当外界调用时才进行实例化。

2.1 懒汉实现：基础方法

是否多线程安全：否
实现难度：易
描述：这种方式是最基本的实现方式，这种实现最大的问题就是不支持多线程。因为没有加锁 synchronized，所以严格意义上它并不算单例模式。
缺点：一个是线程安全，另一个是内存泄漏。
线程安全是因为在多线程场景下，有可能出现多个线程同时进行new操作的情况，没通过加锁来限制。
内存泄漏是因为使用了new在堆上分配了资源，那么在程序结束时，也应该进行delete，确保堆中数据释放。

public class Singleton {  
    // 静态私有对象
    private static Singleton instance;  
    // 私有构造函数
    private Singleton (){}  
  
  // 公有接口获取唯一实例
    public static Singleton getInstance() {  
        if (instance == null) {  
            instance = new Singleton();  
        }  
        return instance;  
    }  
}

这种方式在单线程下没有问题，但是如果多线程模式下，当唯一实例还没有创建，两个线程同时调用getinstance就可能同时创建对象，导致错误。

2.2 懒汉实现：基于单锁

是否多线程安全：是
实现难度：较易
描述：这种方式采用单锁机制，有可能造成阻塞。

Singleton*Singleton::getInstance(){
    m.lock();
    if (_instance == nullptr)
        _instance = new Singleton;
    m.unlock();
    return _instance;
}

加锁又会带来另外的性能问题，如果每个线程每次获取实例都加锁，有可能造成阻塞的发生。实际上，上锁的目的是为了防止有多个线程在实例未被初始化的情况下，同时对他进行初始化，如果实例已经被创建了，就不需要考虑这个问题了，所以就可以采用二次加锁的方法来提高程序的性能。

2.3 懒汉实现：基于双重检测锁

是否多线程安全：是
实现难度：较复杂
描述：这种方式采用双锁机制，可以确保线程安全，且在多线程情况下能保持高性能。
getInstance() 的性能对应用程序很关键。

Singleton*Singleton::getInstance(){

    if (_instance == nullptr)
    {
        m.lock();
        if (_instance == nullptr)
        {
            _instance = new Singleton;
        }
        m.unlock();
    }
    return _instance;
}

接下来，我们再解决内存泄漏(资源释放)问题，对懒汉式实现进行进一步的改进。

2.4 懒汉实现：基于双重检测锁和资源管理

是否多线程安全：是
实现难度：较复杂
描述：这种方式采用双锁机制，可以确保线程安全，且在多线程情况下能保持高性能。并且加入资源管理机制，以达到对资源的释放的目的。
我们加入资源管理机制，以达到对资源的释放的目的，解决方法有两个：智能指针&静态嵌套类。

2.4.1 智能指针方式

将实例指针更换为智能指针，另外智能指针在初始化时，还需要人为添加公有的毁灭函数，因为析构函数私有化了。

#include <iostream>
#include <mutex>
using namespace std;

// 单例模式演示类
class Singleton
{
public:
// 公有接口获取唯一实例
	static shared_ptr<Singleton> getInstance() {
// 若为空则创建
		if (instance == nullptr) {
// 加锁保证线程安全
// 如果两个线程同时进行到这一步，一个线程继续向下执行时，另一个线程被堵塞
// 等锁解除后，被堵塞的线程就会跳过下面的if了，因为此时实例已经构建完毕
		lock_guard<mutex> l(m_mutex);
		if (instance == nullptr) {
			cout << "实例为空，开始创建。" << endl;
			instance.reset(new Singleton(), destoryInstance);
			cout << "地址为:" << instance << endl;
			cout << "创建结束。" << endl;
		}
	}
		else {
			cout << "已有实例，返回。" << endl;
		}
	return instance;
}
// 毁灭实例
static void destoryInstance(Singleton* x) {
	cout << "自定义释放实例" << endl;
	delete x;
}

private:
// 私有构造函数
Singleton() {
	cout << "构造函数启动。" << endl;
};

// 私有析构函数
~Singleton() {
	cout << "析构函数启动。" << endl;
};

private:
// 静态私有对象
static shared_ptr<Singleton> instance;
// 锁
static mutex m_mutex;
};

// 初始化
shared_ptr<Singleton> Singleton::instance;
mutex Singleton::m_mutex;

应用智能指针后，在程序结束时，它自动进行资源的释放，解决了内存泄漏的问题。

2.4.2 静态嵌套类方式

类中定义一个嵌套类，初始化该类的静态对象，当程序结束时，该对象进行析构的同时，将单例实例也删除了。

#include <iostream>
#include <mutex>
using namespace std;

// 单例模式演示类
class Singleton
{
public:
// 公有接口获取唯一实例
static Singleton* getInstance() {
// 若为空则创建
	if (instance == nullptr) {
// 加锁保证线程安全
// 如果两个线程同时进行到这一步，一个线程继续向下执行时，另一个线程被堵塞
// 等锁解除后，被堵塞的线程就会跳过下面的if了，因为此时实例已经构建完毕
		lock_guard<mutex> l(m_mutex);
		if (instance == nullptr) {
			cout << "实例为空，开始创建。" << endl;
			instance = new Singleton();
			cout << "地址为:" << instance << endl;
			cout << "创建结束。" << endl;
			}
	}
		else {
			cout << "已有实例，返回。" << endl;
			}
	return instance;
}

private:
// 私有构造函数
Singleton() {
	cout << "构造函数启动。" << endl;
	};

// 私有析构函数
~Singleton() {
cout << "析构函数启动。" << endl;
};

// 定义一个删除器
class Deleter {
public:
Deleter() {};
~Deleter() {
if (instance != nullptr) {
	cout << "删除器启动。" << endl;
	delete instance;
	instance = nullptr;
	}
}
};

// 删除器是嵌套类,当该静态对象销毁的时候，也会将单例实例销毁
static Deleter m_deleter;
private:
// 静态私有对象
static Singleton* instance;
// 锁
static mutex m_mutex;
};

// 初始化
Singleton* Singleton::instance = nullptr;
mutex Singleton::m_mutex;
Singleton::Deleter Singleton::m_deleter;

2.5 懒汉实现：基于局部静态对象

是否多线程安全：是
实现难度：一般
描述：C++11后，规定了局部静态对象在多线程场景下的初始化行为，只有在首次访问时才会创建实例，后续不再创建而是获取。若未创建成功，其他的线程在进行到这步时会自动等待。注意C++11前的版本不是这样的。

因为有上述的改动，所以出现了一种更简洁方便优雅的实现方法，基于局部静态对象实现。

#include <iostream>
#include <mutex>
using namespace std;

// 单例模式演示类
class Singleton
{
public:
// 公有接口获取唯一实例
static Singleton& getInstance() {
	cout << "获取实例" << endl;
	static Singleton instance;
	cout << "地址为:" << &instance << endl;
	return instance;
	}
private:
// 私有构造函数
Singleton() {
	cout << "构造函数启动。" << endl;
	};

// 私有析构函数
~Singleton() {
	cout << "析构函数启动。" << endl;
	};
};

3. 饿汉式

饿汉模式特点是一开始就对实例进行初始化，调用时直接返回这个构建好的实例。

3.1 饿汉实现：基础方法

是否多线程安全：是
实现难度：易
描述：这种方式比较常用，但容易产生垃圾对象。
优点：没有加锁，执行效率会提高。第一次调用才初始化，避免内存浪费。
缺点：类加载时就初始化，浪费内存。必须加锁 synchronized 才能保证单例，但加锁会影响效率。
它基于 classloader 机制避免了多线程的同步问题，不过，instance 在类装载时就实例化，虽然导致类装载的原因有很多种，在单例模式中大多数都是调用 getInstance 方法， 但是也不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化 instance 显然没有达到 lazy loading 的效果。

#include <iostream>
#include <mutex>
using namespace std;

// 单例模式演示类
class Singleton
{
public:
// 公有接口获取唯一实例
static Singleton* getInstance() {
	cout << "获取实例" << endl;
	cout << "地址为:" << instance << endl;
	return instance;
	}
private:
// 私有构造函数
Singleton() {
	cout << "构造函数启动。" << endl;
};

// 私有析构函数
~Singleton() {
	cout << "析构函数启动。" << endl;
};

private:
// 静态私有对象
static Singleton* instance;
};

// 初始化
Singleton* Singleton::instance = new Singleton();

main还没开始，实例就已经构建完毕，获取实例的函数也不需要进行判空操作，因此也就不用双重检测锁来保证线程安全了，它本身已经是线程安全状态了。
但是内存泄漏的问题还是要解决的，这点同懒汉是一样的。可以通过智能指针和静态嵌套实现。

4. 总结

一般情况下，建议使用基于双重检测锁和资源管理搭配智能指针的懒汉方式。

花好约猿上王者
关注
  • 16
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言静态函数库的制作和使用方法
01-19
作者：杨硕，华清远见嵌入式学院讲师。 　　一．库函数简介： 　　C语言中有一些函数会执行一些标准任务，可以事先对这些函数进行编译，然后将他们放置在一些特殊的目标代码文件中，这些目标代码文件称为库。 　　库文件中的函数可以通过连接程序与应用程序进行链接，这样就不用在每次执行程序时都对这些通用的函数进行编译了。 　　标准的C函数库名称为libc，包含了诸如内存管理或者输入输出操作的基本函数。这些库放置在系统的公用目录下，如/usr/lib，系统中的任何用户都可以利用这些库函数，用户也可以自己建立库。 　　库的两种形式：静态库；共享库 　　二.静态库： 　　1）基本概念： 　　静态库
【面经专栏】独家整理【C++】面经
日月既往，不可复追
10-18 1992
C++ 1、动态库的查找顺序 ELF文件的DT_RPATH段 环境变量LD_LIBRARY_PATH 库高速缓存/etc/ld.so.cache文件列表 默认路径/lib /usr/lib 2、虚继承，多重继承中派生类对象内有谁 3、RTTI，typeid是怎么知道指向对象的类型的 ​ typeid函数的主要作用就是让用户知道当前的变量是什么类型的，比如使用typeid(a).name()就能知道变量a是什么类型的。typeid()函数的返回 类型为type_info类型的引用 ​ 运行时的多态是通
C++基础进阶
qq_39343746的博客
11-20 537
C++学习时的一些整理
【C++】C++ 单例模式总结（5种单例实现方法）
热门推荐
unonoi的博客
11-04 7万+
C++ 单例模式的几种实现方式。
C++ 11 单例模式
yljxh的博客
06-01 280
【代码】C++ 11 单例模式。
C++设计模式之单例模式
09-04
主要介绍了C++设计模式之单例模式,本文同时给出了4种单例模式的实现代码,需要的朋友可以参考下
C++单例模式应用实例
12-31
本文实例讲述了C++单例模式及其相关应用方法，分享给大家供大家参考。具体方法分析如下： 定义： 一个类有且仅有一个实例，并且提供一个访问它的全局访问点。 要点： 1、类只能有一个实例； 2、必须自行创建此实例；...
设计模式C++学习之单例模式（Singleton）
09-07
设计模式C++学习之单例模式（Singleton）
使用C++11实现线程安全的单例模式
04-05
C++11实现线程安全的单例代码和测试代码，包含singleton.h，main.cpp，希望帮助到大家。
C++实现 单例模式实例详解
08-30
主要介绍了C++实现 单例模式实例详解的相关资料,需要的朋友可以参考下
QTablewidget 鼠标悬停显示提示内容(Tooltip)
Zander0的博客
06-17 1万+
QTablewidget 鼠标悬停显示提示内容Tooltip一.环境及适用范围二.实现方法1. 开启鼠标捕获2. 接收和处理信号三. 具体源码1. 头文件2. cpp文件 Qt中GUI设计经常会使用到QTabaleWidget控件，有时Item中显示的文字内容比较多，如果设置Item过大的话，文字虽然可以显示出来，但是整个页面就会显示的Item比较少。所以为了多显示Item，每个Item的大小设置还是要适中一些，带来的问题就是每个Item中显示的内容不全。但是还必须要让用户了解每一个Item中的内容，所有为
[error]stack smashing detected
Zander0的博客
01-20 6834
运行环境： 程序是在Linux环境中的 qt 运行的。 遇到过两种出错情况：一. 程序运行后中止，出现上述错误。二. 程序在当前Linux版本上编译后可运行，放到其它Linux版本上不能够运行，出现上述错误。简意就是，本Linux系统版本上编译的可执行程序只能在同Linux系统版本运行。 **第一种情况：**出现stack smashing detected，即栈溢出，但不会定位到哪里出现溢出。 1.原因：C语言比较“宽松、灵活，语法检查不严格”，在遇到数组越界、栈溢出等问题时编译时不会报出来，等到程序运行
如何在C++中调用C函数？
Zander0的博客
01-19 6557
标题 如何在C++中调用C函数？ 假如在一个项目中同时包含了C和C++，当C++调用C函数时，以传统C编程#include "xxx.h"后，声明函数。由于main.cpp 是个C++代码，以C方式的调用，g++编译器无法通过编译。 解决方案一： 重写一个专门被c++用的头文件（可能存在是别人已经写好的头文件，我们无法修改等问题） e.g. 添加一个头文件 tansfer.h extern "C" { #include "file1.h" #include "file2.h" } 最后在需要调用C函数的c
C++ 将十六进制字符串转换为二进制字符串
Zander0的博客
08-04 6388
C++ 将十六进制字符串转换为二进制字符串前言一. 源代码 前言 一种简单的方法将十六进制字符串转为二进制字符串，不限制十六进制的字节数。 一. 源代码 传入的十六进制字符串需要转换为大写！(%X, toupper())。 string GetBinaryStringFromHexString (string strHex) { string sReturn = ""; unsigned int len = strHex.length(); for (unsigned int i
Visual Studio如何实现.exe免安装免DLL运行[动态链接库---＞＞＞静态链接库]
Zander0的博客
05-04 3292
Visual Studio如何实现.exe免安装免DLL运行[动态链接库--->>>静态链接库]前言一. debug下的配置方法二. release下的配置方法 前言 目的：Visual Studio编译生成的.exe可执行文件，可以免安装免DLL在其他电脑直接运行。换句话说，将执行程序的动态链接库改成静态链接库。 测试程序：测试程序分为 有MFC使用 和 无MFC使用。 方法：就是在编译可执行文件的时候，将可执行文件需要调用的对应动态链接库中的部分提取出来，链接到可执行文件中去，使可执
C++ 多字节编码与Unicode编码
Zander0的博客
05-06 3171
C++ 多字节编码与Unicode编码前言一. 什么是字符集（Charcater Set）与字符编码（Encoding）？二. 不同字符集的区别1. 不同字符集2. 优缺点三. char与wchar_t、string 与 wstring1. char与wchar_t2. string与wstring3. string与wstring转换四. 理解_T()、_Text()宏即L“ ”五. Dword、LPSTR、LPWSTR、LPCSTR、LPCWSTR、LPTSTR、LPCTSTR 前言 任何“物种”都有
如何终止进程（结束main函数）？
Zander0的博客
01-19 2986
标题 如何终止main函数 C++中： 1. return 1; 2. exit(1)； 注：需要引用#include <stdlib.h>
如何把一个十六进制byte数组转成十进制整数。
Zander0的博客
11-20 2126
如何把一个十六进制byte数组转成十进制整数。 如 byte[2] = {0x01,0x00},即十六进制为0x0100，最终转为"256"? eg: byte[n] 转为十进制 for (int i = 0; i<n; i++) { result *= 256; result += byte[n-1-i]; }
C++代码 单例模式
最新发布
08-15
在C++中，实现单例模式可以使用以下方法： ```cpp class Singleton { private: static Singleton* instance; Singleton() {} // 私有构造函数，防止实例化 public: static Singleton* getInstance() { if ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值