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

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

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




![img](https://img-blog.csdnimg.cn/img_convert/5614d0f53297171f252e39e631d56602.png)
![img](https://img-blog.csdnimg.cn/img_convert/c13f6b1097fc8839932e9748c8d568fc.png)

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

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


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

67235)]

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

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


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