最全Qt5开发从入门到精通——第十二篇二节（Qt5 事件处理及实例—(1)，2024年最新特殊渠道拿到阿里大厂面试真题_qt开发实例

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

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

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

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;	
}

1
2
3
4
5
6
7
8
9
10
11

在上述的代码段中，虽然 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;
		
}

1
2
3
4
5
6
7
8
9
10
11
12

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();
}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81

四、线程等待与唤醒

使用 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


![img](https://img-blog.csdnimg.cn/img_convert/7f1a7cdb4008406964a4d90c8bcb61ad.png)
![img](https://img-blog.csdnimg.cn/img_convert/6c209b8509a0bb04a50de3d681454a67.png)

**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**[需要这份系统化资料的朋友，可以戳这里获取](https://bbs.csdn.net/topics/618545628)**


**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**

WHB-1715796970102)]

**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**[需要这份系统化资料的朋友，可以戳这里获取](https://bbs.csdn.net/topics/618545628)**


**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89