Qt5开发从入门到精通——第十二篇二节（Qt5 事件处理及实例——多线程控制、互斥量、信号量、线程等待与唤醒）

最新推荐文章于 2024-05-21 15:51:39 发布

东.'

最新推荐文章于 2024-05-21 15:51:39 发布

阅读量1.1k

点赞数 11

分类专栏： Qt5开发从入门到精通文章标签： qt 开发语言 c++ windows c语言

本文链接：https://blog.csdn.net/weixin_44759598/article/details/127991301

版权

Qt5开发从入门到精通专栏收录该内容

56 篇文章 156 订阅

订阅专栏

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

前言

本章节会给大家带来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、效果实例

图二
在这里插入图片描述

4.2、原码实例

main.cpp

#include <QCoreApplication>
#include <QWaitCondition>
#include <QMutex>
#include <QThread>
#include <stdio.h>

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;i<DataSize;i++)/*for 循环中的所有语句都需要使用互斥量加以保护，以保证其操作的原子性。*/
    {
        mutex.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 事件处理及实例——多线程控制、互斥量、信号量、线程等待与唤醒会在应用程序开发中经常用到的。

东.'

关注

11
点赞
踩
18

收藏

觉得还不错? 一键收藏
打赏
20
评论
Qt5开发从入门到精通——第十二篇二节（Qt5 事件处理及实例——多线程控制、互斥量、信号量、线程等待与唤醒）

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

扫一扫