[waiting and wakeup of QT multithreaded threads]

QWatiCondition Of Member functions

·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 )
Parameters ：
（1） Release the locked mutex
（2） Blocking time
function ：
mutex Will be unlocked , And the calling thread will block , I don't want to come until one of the following conditions is met ：
（1） Another thread uses wakeOne() or wakeAll() Transmit to it ;
（2）time Milliseconds past .

wakeAll()
function ： Wakes up all waiting threads .

wakeOne()
function ： Wake up and wait QWaitCondition One of the threads of .

* Be careful ： Here I can't distinguish yet wakeAll() and wakeOne() The difference between

Example 1： Consumers and producers
The main points of ：
（1） The producer must check whether the buffer is full （numUsedBytes == BufferSize）, If it is , The thread stops and waits bufferEmpty.wakeAll(); If not , The production data , increase numUsedBytes , Activate numUsedBytes ==80

（2） When the program starts running , Only producers can run . Consumers are blocked waiting bufferFull.wakeAll(); Once the producer puts a byte in the buffer , The consumer thread is awakened .

（3） The transition from a locked state to a waiting state is an atomic operation ...（ First exposure to atomic operation ）

It is mainly divided into 3 Parts of ：
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);   // The capacity is full , Producer blocking 
        buffer[i%BufferSize] = i%BufferSize;
        numUsedBytes++;      // Used to record whether the current buffer is full 
        bufferFull.wakeAll();        // Buffer has capacity , Wake up consumers 
        mutex.unlock();
    }
}

Comsumer::Comsumer()
{

}

Comsumer::~Comsumer()
{

}

void Comsumer::run()
{
    for (int i = 0; i < DataSize; i++)
    {
        mutex.lock();
        if (numUsedBytes == 0)
            bufferFull.wait(&mutex);  // Capacity is empty , Block consumers    
        qDebug() << currentThreadId() << buffer[i%BufferSize];
        numUsedBytes--;
        bufferEmpty.wakeAll();     // The buffer is not full , Wake up producers 
        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();
}

Some doubts about this example ？
This example contains 4 Threads , The main thread , Producer thread , Consumer thread 1, Consumer thread 2;
The problem is ： In the producer thread bufferEmpty.wakeAll() Trigger , Automatically unlock() after ; Mutex is in a situation that needs to be preempted , That is, the consumer thread 1 And consumer threads 2 preemption . that , Will there be consumer threads 1 Keep grabbing , and 2 What about the situation that cannot be preempted ？
Here is my program diagram

 

It was found that the thread was used at the beginning 1 preemption , Then there are threads 1 and 2 Alternate preemption
————————————————
Copyright notice ： This paper is about CSDN Blogger 「yxy654538632」 The original article of , follow CC 4.0 BY-SA Copyright agreement , For reprint, please attach the original source link and this statement .
Link to the original text ：https://blog.csdn.net/yxy654538632/article/details/49496561