接上一篇，本篇文章主要将介绍如何使用 QWaitCondition 来同步线程。
学习 QWaitCondition 类之间，先研读下 Qt 文档对 QwaitCondition 的具体描述及介绍，大意如下：
QWaitCondition 类提供了一个条件变量用于同步线程。
QWaitCondition 允许一个线程告诉其他线程某些条件已被满足。一个或多个线程可以阻塞等待一个由 QWaitCondition 设定的条件 WakeOne() 或 WakeAll()。使用 WakeOne() 去唤醒一个随意选择的线程或者使用 WakeAll() 去唤醒他们所有。
例如，假定当用于按下一个键我们有3条任务应该被执行，每一个任务都可以被分成一个线程，每一个都有一个 run() 主体，就像下面这样：
forever {
mutex.lock();
keyPressed.wait(&mutex);
do_something();
mutex.unlock();
} 在这里，keyPressed 是一个 QWaitCondition 类型的全局变量。
第4条线程可以读取键的按压，每次接受一次，就会唤醒其他3条线程，就像下面这样：
forever {
getchar();
keyPressed.wakeAll();
} 这3条线程唤醒顺序是未定义的。另外，如果当键被按压仍有一些线程在执行 do_something() ，那么，键按压之后它们将不会被唤醒（因为它们没有等待条件变量）并且任务也不会去执行。这个问题可以使用计数器和 QMutex 去防护解决它。例如，这里有个新的代码用于工作线程：
forever {
mutex.lock();
keyPressed.wait(&mutex);
++count;
mutex.unlock();
do_something();
mutex.lock();
--count;
mutex.unlock();
} 这里有个代码是用于第4条线程的：
forever {
getchar();
mutex.lock();
// Sleep until there are no busy worker threads
while (count > 0)
{
mutex.unlock();
sleep(1);
mutex.lock();
}
keyPressed.wakeAll();
mutex.unlock();
} 互斥量是必须的，因为两条线程尝试同时修改相同变量的值，其结果是不可预知的。
原始的同步线程中使用等待条件是强而有力的，Wait Conditions Example 这个例子显示了如何使用 QWaitCondition 替代 QSemaphore 去控制访问环形共享内存通过生产者线程和消费者线程。
好吧，到此为止，我只是把 Qt 帮助文档翻译了一遍。
现在上 Qt 自带样例代码：
【Producer.h】
#ifndef PRODUCER_H【Producer.cpp】
#define PRODUCER_H
#include <QThread>
#include <QMutex>
#include <QWaitCondition>
#include <iostream>
extern QMutex mutex;
extern const int DataSize;
extern const int BufferSize;
extern char buffer[8];
extern int numUsedBytes;
extern QWaitCondition bufferNotEmpty;
extern QWaitCondition bufferNotFull;
class Producer : public QThread
{
public:
explicit Producer(QObject* parent = NULL);
virtual void run();
};
#endif // PRODUCER_H
#include "producer.h"
#include <QTime>
Producer::Producer(QObject* parent) : QThread(parent)
{
}
void Producer::run()
{
qsrand(QTime(0, 0, 0).secsTo(QTime::currentTime()));
for(int i = 0; i < DataSize; i++)
{
/*
* QMutex: The purpose of a QMutex is to protect an object,
* data structure or section of code so that only one thread can
* access it at a time
* QMutex可以抱回一个对象, 数据结构, 以及代码段在同一时刻只能有一条线程访问
*
* 锁住, 保护对变量的访问, 每次只有一条线程能访问
*/
mutex.lock();
//如果可用缓冲区是满的, 则堵塞当前线程, 等待消费者线程读取
if(numUsedBytes == BufferSize)
{
/*
* 释放互斥量, 并阻塞线程等待条件
* 解锁条件是: wakeOne() or wakeAll() 以及 timeout
*/
bufferNotFull.wait(&mutex);
}
mutex.unlock();
buffer[i % BufferSize] = "ACGT"[(int)qrand() % 4];
std::cout << buffer[i % BufferSize] << std::endl;
//锁住变量 numUsedBytes
mutex.lock();
++numUsedBytes;
//通知生产者线程
bufferNotEmpty.wakeAll();
//解锁
mutex.unlock();
}
}
【Consumer.h】
#ifndef CONSUMER_H【Consumer.cpp】
#define CONSUMER_H
#include <QThread>
#include <QMutex>
#include <QWaitCondition>
#include <iostream>
extern QMutex mutex;
extern const int DataSize;
extern const int BufferSize;
extern char buffer[8];
extern int numUsedBytes;
extern QWaitCondition bufferNotEmpty;
extern QWaitCondition bufferNotFull;
class Consumer : public QThread
{
public:
explicit Consumer(QObject* parent = NULL);
virtual void run();
signals:
void stringConsumed(const QString& text);
};
#endif // CONSUMER_H
#include "consumer.h"
Consumer::Consumer(QObject* parent) : QThread(parent)
{
}
void Consumer::run()
{
for (int i = 0; i < DataSize; ++i)
{
mutex.lock();
if (numUsedBytes == 0)
{
//如果可用缓存区数据为0, 则通知生产则线程更新数据, 并堵塞当前线程等待条件
bufferNotEmpty.wait(&mutex);
}
mutex.unlock();
std::cout << buffer[i % BufferSize] << std::endl;
//锁住并保护对变量的访问, 每次只有一条线程能访问
mutex.lock();
//清空计数
--numUsedBytes;
//唤醒生产者线程
bufferNotFull.wakeAll();
//解锁
mutex.unlock();
}
}
【main.cpp】
#include <QCoreApplication>
#include "producer.h"
#include "consumer.h"
const int DataSize = 24;
const int BufferSize = 1;
char buffer[8];
int numUsedBytes = 0;
QMutex mutex;
QWaitCondition bufferNotEmpty;
QWaitCondition bufferNotFull;
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();
}
执行结果：
