QT核心-生存线程及事件循环_避免在 qthread 内部直接使用 qeventloop

前言

QT最核心的两个东西莫过于元对象和事件循环了，这两个特性是日常编程中的两大利器，理解和使用好这两个特性对写QT程序有非常大的帮助，就比如QT一个创新功能点信号槽就是利用这两个特性实现(后面可能会单独讲解)，我们这里率先理解一下事件循环，毕竟元对象里面有个东西也是利用事件循环来实现的(后面会说)。

正文

生存线程

首先，我们要知道生存线程的概念，也正是因为QObject的生存线程问题，导致QT的多线程变复杂了，同时功能也更强大了。
大家在网上搜QT多线程的话一定能接触到的一种方式:

QObject o;
QThread t;
t.start();
o.moveToThread(&t);
1
2
3
4

上面moveToThread就是改变对象o的生存线程，该方法的参数为目标线程。下面一行一行代码解析:

1. QObject o;构造一个QObject类型的栈对象o(这里new堆对象也是一样)，在QObject构造时会自动获取当前线程(QThread::currentThread，当然QT内部可能不是调用的这个方法，但基本等价)，获取到的当前线程即为该对象默认生存线程。也即是说，一个继承至QObject的类，它在哪个线程中构造，它的生存线程就是哪个。那么可以得出以下结论:

/*!
 * \brief ThreadTest继承至QThread
 * 由于run函数运行在子线程，所以对象o默认生存线程和该子线程一样，所以下面moveToThread方法无意义
 * 所以下面三个qDebug语句的输出数据一样
 */
void ThreadTest::run()
{
    qDebug() << QThread::currentThread();
    QObject o;
    qDebug() << o.thread();
    o.moveToThread(QThread::currentThread());
    qDebug() << o.thread();
}
1
2
3
4
5
6
7
8
9
10
11
12
13

2. QThread t;构造一个线程，但要注意，因为QThread也是继承至QObject，所以它也有生存线程，但是它的生存线程对它的run方法的执行线程不会造成影响。
3. t.start();启动线程，QThread的run方法默认有一个实现，是调用它自身的exec方法启动一个事件循环。

void QThread::run()
{
    (void) exec();
}
int QThread::exec()
{
    Q_D(QThread);
    QMutexLocker locker(&d->mutex);
    d->data->quitNow = false;
    if (d->exited) {
        d->exited = false;
        return d->returnCode;
    }
    locker.unlock();

    QEventLoop eventLoop;
    int returnCode = eventLoop.exec();

    locker.relock();
    d->exited = false;
    d->returnCode = -1;
    return returnCode;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

这里就是在子线程中开启了一个事件循环，这个事件循环会管理它所在线程的所有事件，并将事件抛给相应的同属该线程的对象。
4. o.moveToThread(&t);改变对象o的生存线程为t，这里要注意的是，QT规定只能将当前线程中的对象的生存线程改为其他线程，不能将其他线程中的对象的生存线程改为当前线程，所以这里如果还想要将对象o的生存线程改变的话只能在线程t中更改，其他任何线程中都不能更改，具体请查看QT助手。
5. 这个时候再向对象o抛一个事件的话，那么对象o的event方法将会在线程t中执行。注意: 这里应该用postEvent而非sendEvent。
下面给出一个完整的例子以供理解:

// 头文件
#pragma once

#include <QObject>

class ObjectTest : public QObject
{
    Q_OBJECT
public:
    explicit ObjectTest(QObject *parent = nullptr);

    void customEvent(QEvent *event) override;

signals:
    
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

// cpp文件
#include "ObjectTest.h"

#include <QDebug>
#include <QEvent>
#include <QThread>

ObjectTest::ObjectTest(QObject *parent) : QObject(parent)
{
}

void ObjectTest::customEvent(QEvent *event)
{
    qDebug() << "event type:" << event->type();
    qDebug() << "ObjectTest thread:" << thread();
    qDebug() << "cur thread:" << QThread::currentThread();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

// 使用这个类，注意: 这里的m_d变量是一个属性，请在合适的地方声明这个属性
qDebug() << "main thread:" << QThread::currentThread();
ObjectTest *o = new ObjectTest(); // 构造一个对象，但是不能指定parent，否则不能使用moveToThread
// 向对象中抛一个事件，注意: 这里的Type必须大于等于QEvent::User，否则不能被customEvent接收到。对于小于QEvent::User的事件会被最原始event方法接收
qApp->postEvent(o, new QEvent(static_cast<QEvent::Type>(QEvent::User + 1)));
// 让对象执行之前抛出的事件，否则该事件还未执行时使用moveToThread方法会导致之前未执行的事件也在新线程中执行，注意: moveToThread之后不能再用这个方法
qApp->sendPostedEvents(o);
m_t = new QThread(this);
m_t->start();
qDebug() << "new thread:" << m_t;
o->moveToThread(m_t);
qApp->postEvent(o, new QEvent(static_cast<QEvent::Type>(QEvent::User + 1)));
1
2
3
4
5
6
7
8
9
10
11
12

// 执行输出结果
main thread: QThread(0x16dfd0bad20)
event type: QEvent::Type(1001)
ObjectTest thread: QThread(0x16dfd0bad20)
cur thread: QThread(0x16dfd0bad20)
new thread: QThread(0x16dfd0fb620)
event type: QEvent::Type(1001)
ObjectTest thread: QThread(0x16dfd0fb620)
cur thread: QThread(0x16dfd0fb620)
1
2
3
4
5
6
7
8
9

总结而言: 所谓生存线程就是QObject及其子类的event和衍生事件方法的执行线程。
剩下的东西单开一章吧，否则这篇文章又臭又长。