Qt下实现支持多线程的单例模式

宁静致远20212023-10-28 15:41

Qt下实现支持多线程的单例模式

  • [Chapter1 Qt下实现支持多线程的单例模式($$)](#Chapter1 Qt下实现支持多线程的单例模式($$))
    • [1. 代码介绍](#1. 代码介绍)
    • [2. 代码之路](#2. 代码之路)
    • [3. 详细分析](#3. 详细分析)
      • [3.1 什么是单例](#3.1 什么是单例)
      • [3.2 如何让类无法实例化](#3.2 如何让类无法实例化)
      • [3.3 如何调用这个唯一实例](#3.3 如何调用这个唯一实例)
      • [3.4 如何支持多线程](#3.4 如何支持多线程)
      • [3.5 如何解决内存泄漏](#3.5 如何解决内存泄漏)
    • [4. 结束语](#4. 结束语)
  • [Chapter2 Qt 全局单例类](#Chapter2 Qt 全局单例类)
  • [Chapter3 Qt实用技巧：设计模式之单例模式，唯一实例类通用模板($$)](#Chapter3 Qt实用技巧：设计模式之单例模式，唯一实例类通用模板($$))

实现方式

1、实现单例

把类的构造函数、拷贝构造函数、赋值操作符定义为private的；

把获取单例的接口和唯一的实例指针定义为static的，不需要实例化，直接通过类名即可访问。

2、支持多线程

采用双重校验法，在获取单例的函数中使用互斥锁，确保不会出现两个线程同时new出这个单例类的实例化。

3、解决内存泄漏

析构单例指针，单独写一个类，利用这个类的析构函数来析构单例指针。

Chapter1 Qt下实现支持多线程的单例模式($$$)

原文链接：https://blog.csdn.net/lusanshui/article/details/84142869

1. 代码介绍

实现单例模式的代码很多。

本文的单例模式实现代码是本人一直在工程项目中使用的，现拿出和大家交流分享。

本文实现的单例模式，支持多线程，采用双重校验检索的方式，集成析构类，杜绝内存泄漏，稳定性好。 使用C++/Qt的朋友们可以了解一下。

不再废话，直接上代码。

2. 代码之路

头文件makelog.h

cpp 复制代码 
#include <QMutex>
#include <QObject>
class Makelog: public QObject
{
  	Q_OBJECT
  public:
  	static Makelog* getInstance()
  	{
  		if (m_pInstance == NULL)
  		{
  			QMutexLocker mlocker(&m_Mutex);  //双检索，支持多线程
  			if (m_pInstance == NULL)
  			{
  				m_pInstance = new Makelog();
  			}
  		}
  		return m_pInstance;
  	}
  private:
  	Makelog(){}
  	Makelog(const Makelog&){}
  	Makelog& operator ==(const Makelog&){}

  	static Makelog* m_pInstance;   //类的指针
  	static QMutex m_Mutex;
  public:
  	class CGarbo  //专用来析构m_pInstance指针的类
  	{
  		public:
  		~CGarbo()
  		{
  			if (m_pInstance != NULL)
  			{
  				delete m_pInstance;
  				m_pInstance = NULL;
  			}
  		}
  	};
  	static CGarbo m_Garbo; 					
};

makelog.cpp文件

cpp 复制代码 
Makelog* Makelog::m_pInstance = NULL;
Makelog::CGarbo m_Garbo;
QMutex Makelog::m_Mutex;

支持多线程，无内存泄漏的单例模式就实现了。

下面举例说明具体的使用：

在头文件中加入一个public函数、一个public变量。

cpp 复制代码 
public:
void readFile();
QString m_config;

在源文件中加入函数具体实现，使得readFile()或m_config有实际的意义。

那么，在一个工程内的其他类中，只需做两个步骤，就可以使用这个readFile()函数和m_config变量了。

步骤1：包含头文件

cpp 复制代码 
#include "makefile.h"

步骤2：通过单例类入口调用函数或变量

cpp 复制代码 
Makelog::getInstance()->readFile(); //使用函数
Makelog::getInstance()->m_config; //使用变量

3. 详细分析

3.1 什么是单例

单例是一种软件设计模式，采用单例模式书写的类可以确保在一个工程中只有一个对象实例。再通俗点，就是一个类写好了之后，就不需要也无法再把这个类实例化了，因为写这个类的时候已经确保了有且仅有一个已经实例化的对象。

这样不是很蠢么？花了这么多功夫写了一个类，你告诉我这个类没法用来new出对象了？那我怎么使用这个类？我写个配合静态变量的静态函数，使用起来不是更方便？

当然不蠢，非但不蠢，而且单例模式是所有设计模式中使用最为频繁的一个设计模式。没法new出对象，因为单例模式已经帮你new了一个对象，而且让你的工程中只有这个对象了；使用这个对象只需要包含头文件，然后调用接口指针函数就可以了；静态的全局函数或变量代码实现起来方便，但是不具有类的封装性和灵活性。

3.2 如何让类无法实例化

首先要清楚类实例化无非就是三种方式：

1）采用构造函数实例化；

2）用拷贝函数实现实例化；

3）赋值操作实现实例化。

所以，只需要把这个类的构造函数、拷贝函数、赋值操作写成私有的，就无法调用这些函数，自然就无法实例化了。

正如上文所示的几个函数：

cpp 复制代码 
private:
Makelog(){} //构造函数
Makelog(const Makelog&){} //拷贝函数
Makelog& operator ==(const Makelog&){} //赋值操作符重写

当然，如果有一些初始化的操作，也可以写在私有构造函数的双括号内。

3.3 如何调用这个唯一实例

广泛采用的做法就是在写一个public的函数作为接口，这个函数返回单例类唯一实例的指针。

最简单的写法如下：

cpp 复制代码 
Makelog* getInstance()
{
if (m_pInstance == NULL)
{
m_pInstance = new Makelog(); //调用private构造函数，把唯一实例的指针实例化
}
return m_pInstance;
}
Makelog* m_pInstance; //唯一实例的指针

这个写法看着真不错，可是这么写遇到了一个小小的悖论。

"我如何去调用执行这个getInstance()函数啊，对，我需要一个实例化对象才能去执行！那我去new个对象，等等，唯一的实例化对象是通过这个函数才能找到的啊！"

有方法解决么，当然，类的静态方法不需要实例化对象，用

cpp 复制代码 
类名::方法（）

的形式就可以调用执行了，所以把getInstance()函数前加一个static就好了。

但是静态方法只能使用静态成员变量啊，那就把唯一实例的指针m_pInstance也变成static的吧。

Ok，这样有没有隐患啊？隐患？static类型的instance存在静态存储区，每次调用时，都指向的同一个对象。非但没有隐患，简直堪称完美！

现在上面的代码就变成这样：

cpp 复制代码 
public:
static Makelog* getInstance()
{
if (m_pInstance == NULL ）
{
m_pInstance = new Makelog(); //用私有构造函数new出了这个类的唯一对象
}
return m_pInstance;
}
private:
static Makelog* m_pInstance; //唯一实例指针

这样写完全没有问题，但是不支持多线程的调用。因为new Makelog()需要时间，所以当两个线程同时判断m_pInstance ==NULL，同时执行了m_pInstance = new Makelog()这句代码，问题就大了。

3.4 如何支持多线程

为了解决3.3节产生的bug，广泛采用的方式是双重校验检索的方法。

就是利用互斥锁(用来保证锁内代码最多只有一个线程在同时执行)的方式，确保不会出现两个线程同时new出这个单例类的唯一实例的情况发生。

具体代码如下：

cpp 复制代码 
static Makelog* getInstance()
{
if (m_pInstance == NULL)
{
QMutexLocker mlocker(&m_Mutex); //加锁，锁内代码只有一个线程执行
if (m_pInstance == NULL) //先执行的线程会进入内部new对象，后一个线程判断m_pInstance就不是NULL了
{
m_pInstance = new Makelog();
}
}
return m_pInstance;
}

至此双重校验检索解决多线程问题的单例问题就解决了。当然还可以用原子锁的方法来解决，但是灵活性不强（也可能是我太外行，灵活不起来---。---），这里就不介绍了。

3.5 如何解决内存泄漏

解决单例类的内存析构主要就是解决static Makelog* m_pInstance这个指针的析构问题（毕竟其他的可以不用指针的嘛）。我总结觉得写一个专门用来析构的类是最方便有效和无脑的方法了，推荐给大家。

具体就是在单例类中写一个类：

cpp 复制代码 
public:
class CGarbo //专用来析构m_pInstance指针的类
{
public:
~CGarbo() //这个类只有析构函数
{
if (m_pInstance != NULL)
{
delete m_pInstance;
m_pInstance = NULL;
}
}
};
static CGarbo m_Garbo; //声明一个静态的对象

然后在cpp文件中声明一下 Makelog::CGarbo m_Garbo就可以了。

这个类只有析构函数，析构函数的作用就是delete单例唯一对象的指针。

析构类声明一个static对象，因为静态对象系统会在关闭程序时自动析构，就可以执行到析构函数内部的代码了。

4. 结束语

单例模式是非常常用而基础的一个设计模式，本文作者第一次写博客，有不详或错误之处还请大家指正。对于还在使用C++/Qt的初学者，请不要因为害怕而不去深究和掌握单例模式这个好用实用的工具。

Chapter2 Qt 全局单例类

原文链接：https://blog.csdn.net/z_ujmn/article/details/105299528

单例模式：将构造函数私有，能够禁止类外生成对象。将拷贝构造函数和赋值操作符重载函数声明为delete，以防生成的对象被复制。同时声明一个静态函数和静态互斥锁。静态函数用来生成对象，注意，静态函数不需要通过对象去调用。互斥锁也声明为静态是因为在静态函数里是不能访问类成员变量的，因为静态函数不需要通过对象调用，如果可以访问类成员变量，它自己也不知道访问的是哪个。

cpp 复制代码 
#ifndef APPEVENT_H
#define APPEVENT_H

#include <QObject>
#include <QMutex>
#include <QSharedPointor>

class AppEvent : public QObject
{
    Q_OBJECT
public:
 static QSharedPointer<AppEvent> getInstance();

private:
explicit AppEvent(QObject *parent = 0);

    AppEvent& operator =(AppEvent&) = delete;
    AppEvent(AppEvent&) = delete;
private:
    static QSharedPointer<AppEvent> m_appEvent_ptr;
    static QMutex m_mutex;
signals:

public slots:
};

#endif //APPEVENT_H

静态函数加锁前后分别判断一次可以提高效率。互斥锁以及判断对象是否被创建都保证只会存在一个对象。

cpp 复制代码 
#include "appevent.h"

AppEvent::AppEvent(QObject *parent)
:QObject(parent)
{}

QSharedPointer<AppEvent> AppEvent::m_appEvent_ptr;
QMutex AppEvent::m_mutex;

QSharedPointer<AppEvent> AppEvent::getInstance()
{
	if (nullptr == m_appEvent_ptr){
		m_mutex.lock();
		if (nullptr == m_appEvent_ptr){
			m_appEvent_ptr = QSharedPointer<AppEvent>(new AppEvent);
		}
		m_mutex.unlock();
	}

	return m_appEvent_ptr;
}

其它文件内引用该全局单例对象时，加上单例对象文件的头文件，声明时带上extern。注意，全局单例对象只可初始化一次。

cpp 复制代码 
#include <QApplication>
QSharedPointer<AppEvent> g_appEvent_ptr = AppEvent::getInstace();

int main(int argc, char*argv[])
{
	QApplication a(argc, argv);
	a.exec();
}

Chapter3 Qt实用技巧：设计模式之单例模式，唯一实例类通用模板($$$)

原文链接：https://blog.csdn.net/qq21497936/article/details/80046081

需求

Qt常需要一个类，全局调用，是设计模式中的单例模式。

单例模式

单例模式，是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中，应用该模式的类一个类只有一个实例。即一个类只有一个对象实例。

显然单例模式的要点有三个；

一是某个类只能有一个实例；

二是它必须自行创建这个实例；

三是它必须自行向整个系统提供这个实例。

Qt单例模式示例模板（此版本重大bug）

使用DbService::instance()全局获取该对象

头文件

cpp 复制代码 
#ifndef DBSERVICE_H
#define DBSERVICE_H
 
#include <QObject>
#include <QMutex>
#include <QMutexLocker>
 
class DbService : public QObject
{
    Q_OBJECT
public:
    explicit DbService(QObject *parent = 0);
 
public:
    static DbService * instance();
 
signals:
 
public slots:
 
protected:
 
 
private:
    static DbService *_pInstance;
    static QMutex _mutex;
};
 
#endif // DBSERVICE_H

源文件（存在bug）

cpp 复制代码 
#include "DbService.h"
 
 
DbService * DbService::_pInstance = 0;
QMutex DbService::_mutex;
 
DbService::DbService(QObject *parent) : QObject(parent)
{
 
}
 
DbService * DbService::instance()
{
    if(!_pInstance)
    {
        QMutexLocker lock(&_mutex);
        if(!_pInstance)
        {
            _pInstance = new DbService();
        }
    }
    return _pInstance;
}

bug（感谢网友大神：火龙 的帮助）

cpp 复制代码 
_pInstance = new DbService();
  1. 申请DbService的内存
  2. 在申请的内存上构造DbService
  3. 将_pInstance指针指向这个内存
    这个new有这么三步

编译器可能是132这么执行的，多个线程第一次同时使用时，可能出现野指针，即编译器先指向内存（准备第三步构造）时，另一个线程获取，则出现野指针，运行出现段错误。

源文件（修复完bug）

cpp 复制代码 
#include "DbService.h"
 
 
DbService * DbService::_pInstance = 0;
QMutex DbService::_mutex;
 
DbService::DbService(QObject *parent) : QObject(parent)
{
 
}
 
DbService * DbService::instance()
{
    if(!_pInstance)
    {
        QMutexLocker lock(&_mutex);
        if(!_pInstance)
        {
            DbService *pInstance = new DbService();  // 修改处
            _pInstance = pInstance;                 // 修改处
        }
    }
    return _pInstance;
}

Qt单例模式示例模板（修复bug后的单例模式代码2:使用原子caozuo）

头文件

cpp 复制代码 
#ifndef DBSERVICE_H
#define DBSERVICE_H
 
#include <QObject>
#include <QMutex>
#include <QMutexLocker>
 
class DbService : public QObject
{
    Q_OBJECT
public:
    explicit DbService(QObject *parent = 0);
 
public:
    static DbService *getInstance();
 
signals:
 
public slots:
 
protected:
 
 
private:
    static QAtomicPointer<DbService> _instance;
    static QMutex _mutex;
};
 
#endif // DBSERVICE_H

源文件

cpp 复制代码 
#include "DbService.h"
 
 
QAtomicPointer<DbService> DbService::_instance = 0;
QMutex DbService::_mutex;
 
DbService::DbService(QObject *parent) : QObject(parent)
{
 
}
 
DbService * DbService::instance()
{
#ifndef Q_ATOMIC_POINTER_TEST_AND_SET_IS_ALWAYS_NATIVE
    if(!QAtomicPointer::isTestAndSetNative())//运行时检测
        qDebug() << "Error: TestAndSetNative not supported!";
#endif
    //使用双重检测。
    /*! testAndSetOrders操作保证在原子操作前和后的的内存访问
     * 不会被重新排序。
     */
    if(_instance.testAndSetOrdered(0, 0))//第一次检测
    {
        QMutexLocker locker(&mutex);//加互斥锁。
 
        _instance.testAndSetOrdered(0, new DbService);//第二次检测。
    }
    return _instance;
}
相关推荐
Lizhihao＿4 分钟前
JAVA-队列
java·开发语言
学习路上_write12 分钟前
FPGA/Verilog,Quartus环境下if-else语句和case语句RT视图对比/学习记录
单片机·嵌入式硬件·qt·学习·fpga开发·github·硬件工程
远望清一色22 分钟前
基于MATLAB边缘检测博文
开发语言·算法·matlab
何曾参静谧30 分钟前
「Py」Python基础篇 之 Python都可以做哪些自动化？
开发语言·python·自动化
Prejudices34 分钟前
C++如何调用Python脚本
开发语言·c++·python
我狠狠地刷刷刷刷刷1 小时前
中文分词模拟器
开发语言·python·算法
wyh要好好学习1 小时前
C# WPF 记录DataGrid的表头顺序，下次打开界面时应用到表格中
开发语言·c#·wpf
AitTech1 小时前
C#实现：电脑系统信息的全面获取与监控
开发语言·c#
qing_0406031 小时前
C++——多态
开发语言·c++·多态
孙同学_1 小时前
【C++】—掌握STL vector 类：“Vector简介：动态数组的高效应用”
开发语言·c++
热门推荐
01软件工程从理论到实践客观题汇总(头歌第一章至第八章)02【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总03组基轨迹建模 GBTM的介绍与实现（Stata 或 R）04VSCode插件 —— Cody AI （免费AI助手！）05全面解析：构建基于深度学习的安全帽检测系统（UI界面+YOLO代码+数据集）06Windows10安装PCL1.14.0及点云配准07Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO08文件或文件夹名称中有空格如何批量去除09基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测10【QuikGraph】C#调用第三方库实现迪杰斯特拉(Dijkstra)算法功能