【Qt多线程之线程的等待和唤醒】

QWatiCondition的成员函数

·QWaitCondition()    
·~QWaitCondition()  
·bool wait ( QMutex * mutex, unsigned long time = ULONG_MAX )
·void wakeOne ()
·void wakeAll ()

QWatiCondition::wait()
·bool wait ( QMutex * mutex, unsigned long time = ULONG_MAX )
参数：
（1）释放锁定的mutex
（2）阻塞的时间
功能：
mutex将被解锁，并且调用线程将会阻塞，直到下列条件之一满足才想来：
（1）另一个线程使用wakeOne()或wakeAll()传输给它；
（2）time毫秒过去。

wakeAll()
功能：唤醒所有等待的线程。

wakeOne()
功能：唤醒等待QWaitCondition的线程中的一个线程。

*注意：这里我暂且还不能分清wakeAll()和wakeOne()的区别

例子1：消费者和生产者
要点：
（1）生产者必须检查缓冲是否已满（numUsedBytes == BufferSize），如果是，线程停下来等待bufferEmpty.wakeAll();如果不是，生产数据，增加numUsedBytes ，激活numUsedBytes ==80

（2）当程序开始运行的时候，只有生产者可以运行。消费者被阻塞等待 bufferFull.wakeAll(); 一旦生产者在缓冲中放入一个字节，消费者线程就被唤醒。

（3）锁定状态到等待状态的转换是原子操作。。。（第一次接触到原子操作）

主要分为3个部分：
main.cpp,WatiCondition.h, WatiCondition.cpp

WatiCondition.h
 

#pragma once
#include <QThread>
#include <QtDebug>
#include <QMutex>
#include <QWaitCondition>

class Producer :
    public QThread
{
public:
    Producer();
    ~Producer();

    void run();
};

class Comsumer :
    public QThread
{
public:
    Comsumer();
    ~Comsumer();
    void run();
};

WatiCondition.cpp

#include "WatiCondition.h"
#include <iostream>

QWaitCondition bufferEmpty;
QWaitCondition bufferFull;

QMutex mutex;

const int DataSize = 1000;
const int BufferSize = 80;
int buffer[BufferSize];

int numUsedBytes = 0;
int rIndex = 0;

Producer::Producer()
{

}

Producer::~Producer()
{

}

void Producer::run()
{
    for (int i = 0; i < DataSize; i++)
    {
        mutex.lock();
        if (numUsedBytes == BufferSize)
            bufferEmpty.wait(&mutex);   //容量已满，生产者阻塞
        buffer[i%BufferSize] = i%BufferSize;
        numUsedBytes++;      //用来记录当前缓冲区是否已满
        bufferFull.wakeAll();        //缓冲区有容量，唤醒消费者
        mutex.unlock();
    }
}

Comsumer::Comsumer()
{

}

Comsumer::~Comsumer()
{

}

void Comsumer::run()
{
    for (int i = 0; i < DataSize; i++)
    {
        mutex.lock();
        if (numUsedBytes == 0)
            bufferFull.wait(&mutex);  //容量为空，阻塞消费者   
        qDebug() << currentThreadId() << buffer[i%BufferSize];
        numUsedBytes--;
        bufferEmpty.wakeAll();     //缓冲区未满，唤醒生产者
        mutex.unlock();
    }
    std::cout << std::endl;
}

main.cpp

#include <QCoreApplication>
#include "WatiCondition.h"

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    Producer producer;
    Comsumer consumerA;
    Comsumer consumerB;

    producer.start();
    consumerA.start();
    consumerB.start();

    producer.wait();
    consumerA.wait();
    consumerB.wait();

    return a.exec();
}

关于这个实例的一些疑惑？
这个例子中含有4个线程，主线程，生产者线程，消费者线程1，消费者线程2；
问题就是：生产者线程中的bufferEmpty.wakeAll()触发，自动unlock()之后 ；互斥量处于需要被抢占的情况，也就是消费者线程1和消费者线程2抢占。那么，会不会出现消费者线程1一直抢占，而2抢占不到的情况呢？
下面是我的程序运行图

 

发现一开始都被线程1抢占，后面出现了线程1和2交替抢占的情况
————————————————
版权声明：本文为CSDN博主「yxy654538632」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/yxy654538632/article/details/49496561