【Qt】Qt线程同步之QWaitCondition

Qt—线程同步之QWaitCondition

---

一、简介

​ 在多线程同步开发过程中，QWaitCondition允许线程通知其他线程某一种条件已经满足。一个或多个线程在等待QWaitCondition时将被阻塞。使用wakeOne()函数唤醒一个随机选择的线程，使用wakeAll()函数可唤醒所有的线程。

二、成员函数API

（2-1）等待—wait()

​ 从Qt5.12版本后，wait有以下四种形式：

bool QWaitCondition::wait(QMutex *lockedMutex, QDeadlineTimer deadline = QDeadlineTimer(QDeadlineTimer::Forever))
    
bool QWaitCondition::wait(QMutex *lockedMutex, unsigned long time)

bool QWaitCondition::wait(QReadWriteLock *lockedReadWriteLock, QDeadlineTimer deadline = QDeadlineTimer(QDeadlineTimer::Forever))

bool QWaitCondition::wait(QReadWriteLock *lockedReadWriteLock, unsigned long time) 

（2-2）唤醒一个线程

​ 唤醒一个在等待条件下等待的线程。注：线程被唤醒的顺序取决于操作系统的调度策略，其不能被控制或预测。

void QWaitCondition::wakeOne()

​ 如果想唤醒一个特定的线程，解决方案通常是：使用不同的等待条件，并让不同的线程在不同的条件下等待。即定义多个等待条件，每个线程对应特定的等待条件。

（2-3）唤醒所有线程

​ 唤醒所有在等待条件下等待的线程。与wakeOne一样，线程被唤醒的顺序取决于操作系统的调度策略，其不能被控制或预测。

void QWaitCondition::wakeAll()

三、使用示例

​ 例如，假设有三个任务，当用户按下一个按键时将执行这三个任务。每个任务被分成一个线程，每个线程都有一个run()函数体，如下代码所示：

forever {
    mutex.lock();
    keyPressed.wait(&mutex);
    do_something();
    mutex.unlock();
}

这里，keyPressed变量是一个QWaitCondition类型的全局变量。

第四个线程执行的操作是：读取按键值，并在每次感应到按键时唤醒其他三个线程，如下所示：

forever {
    getchar();
    keyPressed.wakeAll();
}

​ 三个线程被唤醒的先后顺序没有定义。此外，如果某些线程在按下按键时仍处于执行中，那么将不会被唤醒(因为它们没有等待条件变量)，因此任务将不会在按下按键时执行。对于这个问题可以通过：使用一个计数器和一个QMutex来解决。例如，下面的新代码：

forever {
    mutex.lock();
    keyPressed.wait(&mutex);
    ++count;
    mutex.unlock();

    do_something();

    mutex.lock();
    --count;
    mutex.unlock();
}

下面是第四个线程的代码：

forever {
    getchar();

    mutex.lock();
    // 休眠，直到没有忙碌的工作线程
    while (count > 0) {
        mutex.unlock();
        sleep(1);
        mutex.lock();
    }
    keyPressed.wakeAll();
    mutex.unlock();
}

互斥是必要的，因为试图同时更改同一变量值的两个线程，其最后结果是不可预测的。

QWaitCondition等待条件是一个强大的线程同步原语。

下文将使用QWaitCondition替代QSemaphore，来控制对由生产者线程和消费者线程共享的循环缓冲区的访问。

---

四、生产者-消费者模型

​ 【注】本文代码来自官方示例

（4-1）全局变量

const int DataSize = 100000;

const int BufferSize = 8192;
char buffer[BufferSize];

QWaitCondition bufferNotEmpty;
QWaitCondition bufferNotFull;
QMutex mutex;
int numUsedBytes = 0;

​ 为了同步生产者和消费者，需要两个等待条件和一个互斥量。当生产者生成了一些数据时，bufferNotEmpty条件被通知，告诉消费者它可以开始读取数据了。当消费者读取了一些数据时，bufferNotFull条件被通知，告诉生产者它可以生成更多的数据。numUsedBytes是缓冲区中包含数据的字节数。

​ 等待条件、互斥锁和numUsedBytes计数器一起确保生产者永远不会超过消费者的BufferSize字节，并且消费者永远不会读取生产者还没有生成的数据。

（4-2）Producer 生产者类

class Producer : public QThread
{
public:
    Producer(QObject *parent = NULL) : QThread(parent)
    {
    }

    void run() override
    {
        for (int i = 0; i < DataSize; ++i) {
            mutex.lock();
            if (numUsedBytes == BufferSize)
                bufferNotFull.wait(&mutex);
            mutex.unlock();

            buffer[i % BufferSize] = "ACGT"[QRandomGenerator::global()->bounded(4)];

            mutex.lock();
            ++numUsedBytes;
            bufferNotEmpty.wakeAll();
            mutex.unlock();
        }
    }
};

（4-3）Consumer 消费者类

class Consumer : public QThread
{
    Q_OBJECT
public:
    Consumer(QObject *parent = NULL) : QThread(parent)
    {
    }

    void run() override
    {
        for (int i = 0; i < DataSize; ++i) {
            mutex.lock();
            if (numUsedBytes == 0)
                bufferNotEmpty.wait(&mutex);
            mutex.unlock();

            fprintf(stderr, "%c", buffer[i % BufferSize]);

            mutex.lock();
            --numUsedBytes;
            bufferNotFull.wakeAll();
            mutex.unlock();
        }
        fprintf(stderr, "\n");
    }

signals:
    void stringConsumed(const QString &text);
};

（4-4）main函数

int main(int argc, char *argv[])
{
    QCoreApplication app(argc, argv);
    Producer producer;
    Consumer consumer;
    producer.start();
    consumer.start();
    producer.wait();
    consumer.wait();
    return 0;
}