提示：欢迎小伙伴的点评✨✨，相互学习c/c++应用开发。🍳🍳🍳
博主🧑🧑 本着开源的精神交流Qt开发的经验、将持续更新续章，为社区贡献博主自身的开源精神👩‍🚀

文章目录

• 前言
• 一、多线程控制概述
• 二、互斥量
• • 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 
#include 
#include 
#include /*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、效果实例

图二

4.2、原码实例

main.cpp

#include 
#include 
#include 
#include 
#include const int DataSize=160;
const int BufferSize=80;
int buffer[BufferSize];
QWaitCondition bufferEmpty;
QWaitCondition bufferFull;
QMutex mutex; /*使用互斥量保证对线程操作的原子性。*/
int numUsedBytes=0;  /*变量 numUsedBytes 表示存在多少“可用字节”。*/
/*本例中启动了两个消费者线程，并且这两个线程读取同一个缓冲区*为了不重复读取，设置全局变量 rindex 用千指示当前所读取缓冲区位置。*/
int rindex=0;/*Producer 类继承自 QThread 类，其声明如下：*/
class Producer : public QThread
{
public:Producer();void run();
};
/*Producer()构造函数无须实现内容：*/
Producer::Producer()
{}
void Producer::run()
{for(int i=0;imutex.lock();if(numUsedBytes==BufferSize) /*首先检查缓冲区是否已被填满。*/{/*如果缓冲区已被填满，则等待“缓冲区有空位 "(bufferEmpty变量）条件成立。*//*wait()函数将互斥量解锁并在此等待其原型如下：* bool QWaitCondition::wait* (*  QMutex * mutex,unsigned long time= ULONG_MAX* )* ①参数 mutex 为一个锁定的互斥量。如果此参数的互斥量在调用时不是锁定的* 或者出现递归锁定的情况，则 wait()函数将立刻返回。* ②参数 time 为等待时间。* 调用 wait()操作的线程使得作为参数的互斥量在调用前首先变为解锁定状态* 然后自身被阻塞变为等待状态直到满足以下条件之一：* • 其他线程调用了 wakeOne()或者 wakeAll()函数，这种情况下将返回 "true" 值。* • 第 2 个参数 time 超时（以毫秒为单位），该参数默认情况下为 ULONG_MAX* 表示永不超时，这种情况下将返回 "false" 值。* • wait()函数返回前会将互斥量参数重新设置为锁定状态>。* 从而保证从锁定状态到等待状态的原子性转换。*/printf("bufferEmpty.wait (&mutex)1\n");bufferEmpty.wait (&mutex);printf("bufferEmpty.wait (&mutex)2\n");}buffer[i%BufferSize]=numUsedBytes; /*如果缓冲区未被填满，则向缓冲区中写入一个整数值。*/++numUsedBytes;bufferFull. wakeAll(); /*先等待bufferFull.wait(&mutex)，才能唤醒否则为阻塞状态*//*wakeOne() 函数在条件满足时随机唤醒一个等待线程*而wakeAll() 函数则在条件满足时唤醒所有等待线程。*/mutex.unlock();}
}class Consumer : public QThread
{
public:Consumer();void run();
};Consumer::Consumer()
{}
void Consumer::run()
{forever{mutex.lock();if(numUsedBytes==0){printf("bufferFull.wait(&mutex)1\n");bufferFull.wait(&mutex) ;printf("bufferFull.wait(&mutex)2\n");}printf("%ul::[%d]=%d\n",currentThreadId(),rindex,buffer[rindex]);rindex=(++rindex)%BufferSize;--numUsedBytes;bufferEmpty.wakeAll(); /*先等待bufferEmpty.wait (&mutex)，才能唤醒否则为阻塞状态*/mutex.unlock();}}
int main(int argc, char *argv[])
{QCoreApplication a(argc, argv);Producer producer;Consumer consumerA;Consumer consumerB;/*开启一个递增线程两个递减的线程*/producer.start();consumerA.start() ;consumerB.start();/*等待线程运行完后并退出*/producer.wait();consumerA.wait();consumerB.wait();return a.exec();
}

五、总结

Qt5 事件处理及实例——多线程控制、互斥量、信号量、线程等待与唤醒会在应用程序开发中经常用到的。