Qt5开发从入门到精通——第十二篇二节（Qt5 事件处理及实例——多线程控制(1)

2401_84182793

于 2024-04-28 02:58:41 发布

阅读量644

点赞数 27

分类专栏：程序员文章标签： qt 开发语言

本文链接：https://blog.csdn.net/2401_84182793/article/details/138263519

版权

程序员专栏收录该内容

124 篇文章 0 订阅

订阅专栏

前言
一、多线程控制概述
二、互斥量
- 2.1、QMutex 类
  - 2.2、QMutexlocker 类
三、信号量
- 3.1、效果实例
  - 3.２、原码实例
  - - main.cpp
四、线程等待与唤醒
- 4.1、效果实例
  - 4.2、原码实例
  - - main.cpp
五、总结

前言

本章节会给大家带来Qt5 事件处理及实例——多线程控制、互斥量、信号量、线程等待与唤醒详解。介绍 Qt 线程同步、互斥控制的基本方法。线程之间存在着互相制约的关系，具体可分为互斥和同步这两种关系。

一、多线程控制概述

实现线程的互斥与同步常使用的类有 QMutex 、 QMutexLocker 、 QReadWriteLocker 、QReadLocker 、 QWriteLocker 、 QSemaphore 和 QWaitCondition 。
下面举一个例子加以说明：

class Key
{
public:
	Key() {key=0;}
	int creatKey() {++key;return key;}
	int value()const {return key;}
private:
	int key;	
};

这是实现生成从 0 开始递增且不允许重复的值的 Key 类。
在多线程环境下，这个类是不安全的，因为存在多个线程同时修改私有成员 key, 其结果是不可预知的。虽然 Key 类产生主键的函数 creatKey()只有一条语句执行修改成员变量 key 的值，但是 C++的"++“操作符并不是原子操作，通常编译后，它将被展开成为以下三条机器命令：
• 将变量值载入寄存器。
• 将寄存器中的值加 1 。
• 将寄存器中的值写回主存。
假设当前的 key 值为 0, 如果线程 1 和线程 2 同时将 0 值载入寄存器，执行加 1 操作并将加1后的值写回主存，则结果是两个线程的执行结果将互相覆盖，实际上仅进行了一次加 1 操作，此时的 key 值为 1 。为了保证 Key 类在多线程环境下正确执行，上面的三条机器指令必须串行执行且不允许中途被打断（原子操作），即线程 1 在线程 2 (或线程 2 在线程1) 之前完整执行上述三条机器指令。
实际上，私有变量 key 是一个临界资源(Critical Resource, CR )。临界资源一次仅允许被一个线程使用，它可以是一块内存、一个数据结构、一个文件或者任何其他具有排他性使用的东西。在程序中，通常竞争使用临界资源。这些必须互斥执行的代码段称为“临界区 (Critical Section,CS)”。临界区（代码段）实施对临界资源的操作，为了阻止问题的产生，一次只能有一个线程进入临界区。通常有相关的机制或方法在程序中加上“进入”或“离开“临界区等操作。如果一个线程已经进入某个临界区，则另一个线程就绝不允许在此刻再进入同一个临界区。

二、互斥量

互斥量可通过 QMutex 或者 QMutexLocker 类实现。

2.1、QMutex 类

QMutex 类是对互斥量的处理。它被用来保护一段临界区代码，即每次只允许一个线程访问这段代码。
QMutex 类的 lock()函数用与锁住互斥量。如果互斥量处于解锁状态，则当前线程就会立即抓住并锁定它，否则当前线程就会被阻塞，直到待有这个互斥量的线程对它解锁。线程调用 lock()函数后就会待有这个互斥量，直到调用 unlock()操作为止。

class Key
{
public:
Key() {key=O; }
int creatKey() { mutex.lock(); ++key; return key; mutex.unlock();}
int value() const { mutex.lock(); return key; mutex.unlock() ; }
private:
int key;
QMutex mutex;	
}

在上述的代码段中，虽然 creatKey()函数中使用 mutex 进行了互斥操作，但是 unlock()操作却不得不在 return 之后，从而导致 unlock()操作永远无法执行。同样， value()函数也存在这个问
题。

2.2、QMutexlocker 类

Qt 提供的 QMutexLocker 类可以简化互斥量的处理，它在构造函数中接收一个 QMutex 对象作为参数并将其锁定，在析构函数中解锁这个互斥量，这样就解决了以上问题。
例如：

class Key
{
public:
	Key() {key=0;}
	int creatKey(){QmutexLocker locker(&mutex); ++key; return key;}
	int value()const {QmutexLocker locker(&mutex); return key;}
private:
int key;
QMutex mutex;
		
}

locker() 函数作为局部变量会在函数退出时结束其作用域，从而自动对互斥量 mutex 解锁。在实际应用中，一些互斥量锁定和解锁逻辑通常比较复杂，并且容易出错，而使用
QMutexLocker 类后，通常只需要这一条语句，从而大大降低了编程的复杂度。

三、信号量

信号量可以理解为对互斥量功能的扩展，互斥量只能锁定一次而信号量可以获取多次，它可以用来保护一定数量的同种资源。信号量的典型用例是控制生产者／消费者之间共享的环形缓冲区。

3.1、效果实例

图一
在这里插入图片描述

3.２、原码实例

main.cpp

#include <QCoreApplication>
#include <QSemaphore>
#include <QThread>
#include <stdio.h>

/\*freeBytes 信号量控制可被填充的缓冲区部分，被初始化为1
 \* 表示程序一开始有1个char型缓冲区单元可被填充 。\*/
QSemaphore freeBytes(sizeof(char));
/\*usedBytes 信号量控制可被读取的缓冲区部分
 \*被初始化为0, 表示程序一开始时缓冲区中没有数据可供读取。\*/
QSemaphore usedBytes(0);
char buffer[1000];
/\*Producer 类继承自 QThread 类\*/
class Producer : public QThread
{
public:
    Producer();
    void run();
};
/\*Producer()构造函数中没有实现任何内容：\*/
Producer::Producer()
{

}

/\*run函数是实现，线程start的入口\*/
void Producer::run()
{
    for (int i=0;i<5;i++)
    {
        freeBytes.acquire(); /\*acquire 获取空闲单元，如果获取失败对此函数的调用就会阻塞，需要先release读取\*/
        printf("freeBytes.acquire() 获取成功\n");
        buffer[i]=i;
        usedBytes.release(); /\*release 读取缓冲区的数据，如果缓冲区的数据为0，就会阻塞，需要先acquire 获取\*/
        printf("usedBytes.release() 读取成功\n");

    }
}

/\*Consumer 类继承自 QThread 类\*/
class Consumer : public QThread
{
public:
    Consumer();
    void run();
};

/\*Consumer()构造函数中没有实现任何内容：\*/
Consumer::Consumer()
{

}
/\*run函数是实现，线程start的入口\*/
void Consumer::run()
{
    for (int i=0;i<5;i++)
    {
        usedBytes.acquire(); /\*acquire 获取空闲单元，如果获取失败对此函数的调用就会阻塞，需要先release读取\*/
        printf("usedBytes.acquire() 获取成功");
        printf(" 运行第%d次\n",buffer[i]);
        freeBytes.release(); /\*release 读取缓冲区的数据，如果缓冲区的数据为0，就会阻塞，需要先acquire 获取\*/
        printf("freeBytes.release() 读取成功\n");
    }
}

/\*主程序初始化入口\*/
int main(int argc,char \*argv[])
{
    QCoreApplication a(argc, argv);
    Producer producer;
    Consumer consumer;
    producer.start(); /\*开启线程\*/
    consumer.start(); /\*开启线程\*/

    producer.wait(); /\*等待线程运行完后并退出\*/
    consumer.wait(); /\*等待线程运行完后并退出\*/

    return a.exec();
}

四、线程等待与唤醒

使用 QWaitCondition 类，允许线程在一定条件下唤醒其他线程。

4.1、效果实例

图二
在这里插入图片描述

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上大数据知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

需要这份系统化资料的朋友，可以戳这里获取

转存中…(img-wpOWDtK9-1714244301952)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上大数据知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

需要这份系统化资料的朋友，可以戳这里获取

2401_84182793

关注

27
点赞
踩
22

收藏

觉得还不错? 一键收藏
0
评论
Qt5开发从入门到精通——第十二篇二节（Qt5 事件处理及实例——多线程控制(1)

本章节会给大家带来Qt5 事件处理及实例——多线程控制、互斥量、信号量、线程等待与唤醒详解。介绍 Qt 线程同步、互斥控制的基本方法。线程之间存在着互相制约的关系，具体可分为互斥和同步这两种关系。实现线程的互斥与同步常使用的类有 QMutex 、 QMutexLocker 、 QReadWriteLocker 、QReadLocker 、 QWriteLocker 、 QSemaphore 和 QWaitCondition。
复制链接

扫一扫