QThread使用的两种方式
Qt提供了两种线程的使用方式,分别如下:
moveToThread
class Worker : public QObject
{
Q_OBJECT
public slots:
void doWork(const QString ¶meter) {
QString result;
/* ... here is the expensive or blocking operation ... */
emit resultReady(result);
}
signals:
void resultReady(const QString &result);
};
class Controller : public QObject
{
Q_OBJECT
QThread workerThread;
public:
Controller() {
Worker *worker = new Worker;
worker->moveToThread(&workerThread);
connect(&workerThread, &QThread::finished, worker, &QObject::deleteLater);
connect(this, &Controller::operate, worker, &Worker::doWork);
connect(worker, &Worker::resultReady, this, &Controller::handleResults);
workerThread.start();
}
~Controller() {
workerThread.quit();
workerThread.wait();
}
public slots:
void handleResults(const QString &);
signals:
void operate(const QString &);
};
这种方式下worker的slot将会执行在一个独立的线程,但是,我们仍然能够自由的使用connect通过queue connection,这是线程安全的。
subclass QThread
class WorkerThread : public QThread
{
Q_OBJECT
void run() override {
QString result;
/* ... here is the expensive or blocking operation ... */
emit resultReady(result);
}
signals:
void resultReady(const QString &s);
};
void MyObject::startWorkInAThread()
{
WorkerThread *workerThread = new WorkerThread(this);
connect(workerThread, &WorkerThread::resultReady, this, &MyObject::handleResults);
connect(workerThread, &WorkerThread::finished, workerThread, &QObject::deleteLater);
workerThread->start();
}
这种方式需要注意:QThread的实例化版本存在于创建其的线程中,而不是新的线程,对于这种方式而言,只有run函数是运行在一个独立的线程中,所以所有QThread的queue slots都将在老的线程中执行,这意味这如果我们连接槽,那么就要考虑临界资源问题。
Qthread同步
QMutex
QMutex无疑是最常用的线程同步方式,其主要作用是:如果一个线程已经获得了临界资源,第二个线程访问时就会被挂起,直到第一个线程解锁。我们可以像下面这样来使用QMutex:
QMutex mutex;
int number = 6;
void method1()
{
mutex.lock();
number *= 5;
number /= 4;
mutex.unlock();
}
void method2()
{
mutex.lock();
number *= 3;
number /= 2;
mutex.unlock();
}
这种方式本身并没有什么问题,但是可能出现这样一种情况,即在unlock()之前函数就返回了,这是一种很常见的情况,那么此时程序就会被冻结;为了避免这种情况,所以Qt提供了QMutexLocker,它们锁定一个资源,然后在销毁时释放资源。我们可以像下面这样使用:
QMutex mutex;
int complexFunction(int flag)
{
QMutexLocker locker(&mutex);
...
return 1;
}
与QMutex类似的还有QReadWriteLock,其与QMutex的不同在于:QMutex将会锁定资源,包括读写,而QReadWriteLock则支持多个线程同时读取,但是只能一个线程进行写入。从效率上来说,QReadWriteLock更胜一筹。QReadWriteLock也提供了QReadLocker and QWriteLocker以简化使用。
QWaitCondition
QWaitCondition契合了多线程中的生产者 - 消费者模式,考虑一下如果只使用QMutex进行生产者与消费者之间的线程同步会是怎样的情形:当生产者生产产品时未满时,消费者无法消费;当产品还未消费完时,生产者不能生产。这种方式将会带来严重的效率问题,所以这种情形下就需要更加灵活的线程同步,因此需要QWaitCondition。示例代码如下:
const int DataSize = 100000;
const int BufferSize = 8192;
char buffer[BufferSize];
QWaitCondition bufferNotEmpty;
QWaitCondition bufferNotFull;
QMutex mutex;
int numUsedBytes = 0;
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();
}
}
};
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);
};
解析:
- 生产者使用对临界资源使用mutex.lock()上锁,然后检查缓冲区是否满了,如果满了,那么bufferNotFull进入等待,此时可以认为mutex暂时释放,生者者将阻塞在这里。
- 消费者消费产品,产品不再满仓,那么bufferNotFull.wakeAll(),条件激活,但由于消费者中mutex.lock(),生产者暂不启动,但一旦mutex.unlock(),生产者立即获得mutex的控制权,直到mutex.unlock();
这里需要注意的一点是:为什么使用了QWaitCondition还要使用QMutex呢?对此,Qt assistant中给出了解释:
QWaitCondition allows a thread to tell other threads that some sort of condition has been met. One or many threads can block waiting for a QWaitCondition to set a condition with wakeOne() or wakeAll(). Use wakeOne() to wake one randomly selected thread or wakeAll() to wake them all.
也就是说:也就是说,线程获得互斥锁,但是会因为QWaitConation不满足而阻塞,直到有使用wakeOne或者wakeAll来激活。
关于QWaitCondition,有一篇很好的博客可以帮助我们理解,链接如下:https://blog.csdn.net/flyoxs/article/details/54617342
总结:以上只介绍了QMutex、QWaitCondition,但是并不意味着线程同步方式只有这两种,只是因为它们具有代表性而已,至于其他方式,我们还可以使用QSemaphore,这里就不再详述,有兴趣的同学可以去研究一下。
优雅的取消线程
怎样结束一个long Task呢?比较常用的方式如下:
while(!bStop)
{
...
}
通过控制bStop的状态,我们可以结束一个长时间的任务,但是这种使用方式需要注意:因为bStop是一个临界资源,当我们改变它的状态时,需要考虑互斥问题。但实际上,Qt已经为我们做了这方面的考虑,主要依赖于以下两个函数:
- void QThread::requestInterruption()
- bool QThread::isInterruptionRequested() const
前者只是发起一个中断请求,是否响应完全由线程本身决定。后者则对应前者:如果已经发起中断请求,返回true,否则为false。这两个函数都是线程安全的,其源码如下:
void QThread::requestInterruption()
{
Q_D(QThread);
QMutexLocker locker(&d->mutex);
if (!d->running || d->finished || d->isInFinish)
return;
if (this == QCoreApplicationPrivate::theMainThread) {
qWarning("QThread::requestInterruption has no effect on the main thread");
return;
}
d->interruptionRequested = true;
}
bool QThread::isInterruptionRequested() const
{
Q_D(const QThread);
QMutexLocker locker(&d->mutex);
if (!d->running || d->finished || d->isInFinish)
return false;
return d->interruptionRequested;
}
从源码中可以看出,Qt实际已经在实现中加了锁。因此,我们可以放心使用这种方式如下所示:
void long_task() {
forever {
if ( QThread::currentThread()->isInterruptionRequested() ) {
return;
}
}
}
需要注意的是,在Qt助手中,建议我们不要调用isInterruptionRequested()过于频繁,以保持cpu的低开销。