qt messagebox退出程序_深入了解QT消息循环及线程相关性

前言

本篇文章作者为 WPS Windows上的一个开发大佬，经过他同意，发到我的平台上，来给大家分享

这里是知乎作者链接！！https://www.zhihu.com/people/froser

下面为大佬的干货！

一、什么是Qt消息循环

Qt消息循环，就是从一个队列中不断取出消息，并响应消息的过程。窗体的鼠标、键盘、输入法、绘制，各种消息，都来自于Qt的消息循环。以Windows操作系统为例，Qt接管Windows原生窗口消息，并翻译成Qt的消息，派发给程序下的各个子对象、子QWidget等，通过接管层，可以很好屏蔽不同平台之间的差异性，开发人员不需要关心Windows或者X11的消息的差异性，只需要搞清楚各个QEvent之间是什么含义。

最开始的Qt消息循环开始于QCoreApplication::exec()。用户创建出一个QCoreApplication，或者说更多情况下是QApplication，执行QCoreApplication::exec()，一个应用程序便开始了。QCoreApplication会不断从操作系统获取消息，并且分发给QObject。

如果没有消息循环，那么Qt的信号和槽无法完全使用，有些函数也无法正确执行。举个例子，通过QueuedConnection连接的信号，其实是将一个事件压入了消息循环，如果没有QCoreApplication::exec()，那么这个消息循环将永远无法派发到指定的对象。

二、什么是线程相关性

准确点来说，应该是指QObject的线程相关性。以Qt文档中的示意图来作说明：

当我们创建一个QObject时，它会与创建自己所在的线程绑定。它参与的消息循环，其实是它所在线程的消息循环，如上图所示。假如某个线程没有默认的QThread::exec()，那么该线程上的QObject则无法接收到事件。另外，如果两个不同线程的QObject需要相互通信，那么只能通过QueuedConnection的方式，异步通知对方线程，在下一轮消息循环处理QObject的消息。

QObject的线程相关性默认会和它的parent保持一致。如果一个QObject没有parent，那么可以通过moveToThread，将它的线程相关性切换到指定线程。

了解QObject的线程相关性非常重要，很多初学者常常分不清一个多线程中哪些QObject应该由主线程创建，哪些应该由工作线程创建，我的观点是，它参与哪个消息循环，就由哪个来创建。

正因为这样的特性，我们才可以理解什么叫做AutoConnection。通过AutoConnect连接的两个QObject，如果是在同一个线程，那么可以直接调用(DirectConnection)，如果不是在同一个线程，那么就通过事件通知的方式(QueuedConnection)来调用。通过信号和槽、事件或者QueuedConnection方式来进行线程间的通讯，尤其是与UI线程通讯，永远是最优雅的方式之一。

希望大家看了这篇文章后能有所帮助。

全文完。

---

等等，这就完了？这算哪门子深入？？？？

好吧！以下才是正文！

真·深入了解QT消息循环及线程相关性

一、什么是消息循环

以Windows为例，在我们编写GUI程序，创建一个原生窗体时，总会要经历两个步骤：

1、注册一个窗体类(RegisterClassEx):

https://docs.microsoft.com/zh-cn/windows/win32/api/winuser/nf-winuser-registerclassexa

窗体类中，最重要的就是指定了一个窗口处理函数WNDPROC。所有此类型的窗口，收到事件后，都会回调到此处理函数中来执行。

2、创建一个窗体(CreateWindow)

https://docs.microsoft.com/zh-cn/windows/win32/api/winuser/nf-winuser-createwindowexw

一般地，我们可以创建很多个窗口，然后使用同一个窗体处理函数，通过创建时的参数来决定上下文，也就是到底是处理的是哪个Window，以及获取一些自定义结构等。这个函数大致定义了窗体的颜值，并且需要与第一步中的窗体类关联起来。这样一来，窗体就真正创建好了，并且也可以接收到系统发来的消息。

接下来很重要的一点，就是关于消息循环的过程。首先，用户通过GetMessage、PeekMessage等函数，从消息队列中取出事件，接下来，通过DispatchMessage来分发事件。系统将这个事件分发到对应的窗口处理函数WNDPROC中进行处理。在绝大部分GUI程序中，GetMessage, DispatchMessage是写在一个死循环中的，除非程序退出，否则会一直处理各种事件。

二、消息队列的线程相关性

依照MSDN的说法：

https://docs.microsoft.com/zh-cn/windows/win32/winmsg/about-messages-and-message-queues

系统将用创建某Window的线程来分发消息。例如窗体1在线程A创建，窗体2在线程B创建，那么它们的WNDPROC则是由不同线程来回调的。一般地我们也只会在主线程中创建窗体，不过系统还是允许在各个线程中处理窗口的。

三、Qt消息循环的基础：窗体事件

在Windows中，要处理事件一定要有一个窗体。在Qt中，事件一共有两类，一类是和窗体无关的实践，例如QTimerEvent，另外一类就是常见的窗体事件，如鼠标、键盘、绘制等事件。因此，qt至少有两个WNDPROC，一个处理Timer等事件，一个处理QWidget中的事件。

刚刚也提到，Windows事件其实是和线程相关的，那么也就是说，对于每一个QObject的对象，它必须要有自己所在线程的信息。不同线程的对象是无法直接通信的，要通过事件才可以。

在Qt中，消息循环在QEventLoop类中实现。通过QEventLoop::exec()可以进入一个消息循环的阻塞状态中，也就是不断地PeekMessage-DispatchMessage。其实，QEventLoop里面几乎没有实现任何细节，这可能有点令人迷惑，不过仔细想想，任何系统都可以通过QEventLoop来调用消息循环，说明里面一定有一层和系统相关的抽象，这个稍后会说到。

不难想到，QEventLoop通过内部的一层抽象，来不断从系统获取和处理消息，而这一层抽象，是和线程相关的。所有相同的线程，完全可以共用这层抽象。接下来就开始解析Qt4.8中对此的实现。

四、实现

1. QAbstractEventDispatcher

QAbstractEventDispatcher是一个处理PeekMessage-DispatchMessage的抽象接口。Windows上实现的派生类是QEventDispatcherWin32。QEventLoop从某个地方取到这个类的实例，来完成消息的获取和分发。

bool QEventDispatcherWin32::processEvents(QEventLoop::ProcessEventsFlags flags)

{

Q_D(QEventDispatcherWin32);

if (!d->internalHwnd)

createInternalHwnd();

...

do {

....

while (!d->interrupt) {

...

MSG msg;

bool haveMessage;

if (!(flags & QEventLoop::ExcludeUserInputEvents) && !d->queuedUserInputEvents.isEmpty()) {

...

} else {

haveMessage = PeekMessage(&msg, 0, 0, 0, PM_REMOVE);

...

}

if (!haveMessage) {

.....

}

if (haveMessage) {

.....

if (!filterEvent(&msg)) {

TranslateMessage(&msg);

DispatchMessage(&msg);

}

.....

}

retVal = true;

}

} while (canWait);

.....

return retVal;

}

以上是QEventDispatcherWin32的具体实现。我省略掉了大部分代码，只留下几个关键部分。首先是看循环部分，其实就像原生的Windows程序那样，PeekMessage, TranslateMessage, DispatchMessage。我们调用QEventLoop::exec()后，便马上调进了这里。第二个值得注意的是，

if (!d->internalHwnd)

createInternalHwnd();

createInternalHwnd()，QT用它创建了一个不可见的窗口，并且为它注册了一个叫做qtinternalproc的WNDPROC函数：

LRESULT QT_WIN_CALLBACK qt_internal_proc(HWND hwnd, UINT message, WPARAM wp, LPARAM lp)

{

if (message == WM_NCCREATE)

return true;

MSG msg;

msg.hwnd = hwnd;

msg.message = message;

msg.wParam = wp;

msg.lParam = lp;

QCoreApplication *app = QCoreApplication::instance();

long result;

if (!app) {

if (message == WM_TIMER)

KillTimer(hwnd, wp);

return 0;

} else if (app->filterEvent(&msg, &result)) {

return result;

}

#ifdef GWLP_USERDATA

QEventDispatcherWin32 *q = (QEventDispatcherWin32 *) GetWindowLongPtr(hwnd, GWLP_USERDATA);

#else

QEventDispatcherWin32 *q = (QEventDispatcherWin32 *) GetWindowLong(hwnd, GWL_USERDATA);

#endif

QEventDispatcherWin32Private *d = 0;

if (q != 0)

d = q->d_func();

if (message == WM_QT_SOCKETNOTIFIER) {

// socket notifier message

...

return 0;

} else if (message == WM_QT_SENDPOSTEDEVENTS

...

return 0;

} else if (message == WM_TIMER) {

Q_ASSERT(d != 0);

d->sendTimerEvent(wp);

return 0;

}

return DefWindowProc(hwnd, message, wp, lp);

}

可以看到，这个隐藏的窗口处理了几个事件。其中最常用的事件，肯定就是WM_TIMER了。通过QTimer::singleShot进来的事件，最终通过registerTimer()设置了计时器。

void QEventDispatcherWin32Private::registerTimer(WinTimerInfo *t)

{

Q_ASSERT(internalHwnd);

Q_Q(QEventDispatcherWin32);

int ok = 0;

if (t->interval > 20 || !t->interval || !qtimeSetEvent) {

ok = 1;

if (!t->interval) // optimization for single-shot-zero-timer

QCoreApplication::postEvent(q, new QZeroTimerEvent(t->timerId));

else

ok = SetTimer(internalHwnd, t->timerId, (uint) t->interval, 0);

} else {

ok = t->fastTimerId = qtimeSetEvent(t->interval, 1, qt_fast_timer_proc, (DWORD_PTR)t,

TIME_CALLBACK_FUNCTION | TIME_PERIODIC | TIME_KILL_SYNCHRONOUS);

if (ok == 0) { // fall back to normal timer if no more multimedia timers available

ok = SetTimer(internalHwnd, t->timerId, (uint) t->interval, 0);

}

}

if (ok == 0)

qErrnoWarning("QEventDispatcherWin32::registerTimer: Failed to create a timer");

}

当SetTimer超时后，WM_TIMER将发送给internalHwnd，接下来它调用sendTimerEvent，通知接收的QObject，达到计时器的效果。

通过创建一个隐藏的窗口，来处理一些特定的事件，这便是Qt消息循环的一个小小的套路。

2. QThreadData

你可能会问，QEventDispatcherWin32的实例存放在哪里。前文也说过，QEventDispatcherWin32是跟着线程走的，所以没有必要每个QEventLoop都存一个。事实上，它存放在一个叫做QThreadData的结构中：

class QThreadData

{

QAtomicInt _ref;

public:

QThreadData(int initialRefCount = 1);

~QThreadData();

static QThreadData *current();

static QThreadData *get2(QThread *thread)

{ Q_ASSERT_X(thread != 0, "QThread", "internal error"); return thread->d_func()->data; }

void ref();

void deref();

QThread *thread;

bool quitNow;

int loopLevel;

QAbstractEventDispatcher *eventDispatcher;

QStack<QEventLoop *> eventLoops;

QPostEventList postEventList;

bool canWait;

QVector<void *> tls;

QMutex mutex;

# ifdef Q_OS_SYMBIAN

RThread symbian_thread_handle;

# endif

};

仔细看看这个结构，它几个主要的成员，eventDispatcher，就是我们刚刚说的QEventDispatcherWin32实例。eventLoops，这个是嵌套的消息循环，以及loopLevel，是它嵌套的层数(如QEventLoop::exec里面调用QEventLoop:exec)。里面还有个postEventList，表示当前的Qt事件队列，thread表示它当前所在的线程，以及一个_ref引用计数。

QThreadData奇妙在，它是跟着线程走的。在QThreadData::current中我们可以看到：

QThreadData *QThreadData::current()

{

qt_create_tls();

QThreadData *threadData = reinterpret_cast<QThreadData *>(TlsGetValue(qt_current_thread_data_tls_index));

if (!threadData) {

...

} else {

threadData = new QThreadData;

// This needs to be called prior to new AdoptedThread() to

// avoid recursion.

TlsSetValue(qt_current_thread_data_tls_index, threadData);

QT_TRY {

threadData->thread = new QAdoptedThread(threadData);

} QT_CATCH(...) {

TlsSetValue(qt_current_thread_data_tls_index, 0);

threadData->deref();

threadData = 0;

QT_RETHROW;

}

threadData->deref();

}

...

}

return threadData;

}

我们发现，调用此方法后，如果线程栈的局部存储区中没有QThreadData，一个新的QThreadData就会被创建，并且设置到当前线程的局部存储区，并且将当前线程绑定在一个假的QAdoptedThread中。

接下来是最重要的一点：所有的QObject中都有QThreadData的成员，并且有下列初始化：

QObject::QObject(QObjectPrivate &dd, QObject *parent)

: d_ptr(&dd)

{

Q_D(QObject);

d_ptr->q_ptr = this;

d->threadData = (parent && !parent->thread()) ? parent->d_func()->threadData : QThreadData::current();

d->threadData->ref();

.....

}

这样就非常清晰明了了，我创建一个QObject对象，它的threadData，将和parent一致。若parent没有threadData，或者是没有parent，将调用QThreadData::current获取一个新的、当前线程的QThreadData，并且将当前线程设置为一个QAdoptedThread的实例。

下面看一下QEventLoop::processEvents的实现，QEventLoop::exec()最终调入此处：

bool QEventLoop::processEvents(ProcessEventsFlags flags)

{

Q_D(QEventLoop);

if (!d->threadData->eventDispatcher)

return false;

if (flags & DeferredDeletion)

QCoreApplication::sendPostedEvents(0, QEvent::DeferredDelete);

return d->threadData->eventDispatcher->processEvents(flags);

}

原来QEventLoop作为一个QObject，它也有threadData。同一个线程threadData只创建一次，所以它们取出来的eventDispatcher也都是相同的。这意味着所有的相同线程的QObject，共享一份threadData，也就是同一份eventDispatcher, postEventList等。这也就说明了，我们下图是如何实现的：

事件保存在QThreadData::postEventList中，不同线程有不同的QThreadData实例

3. QThread

接下来看看当我们创建一个线程时，会发生什么：

QThreadPrivate::QThreadPrivate(QThreadData *d)

: QObjectPrivate(), running(false), finished(false), terminated(false), exited(false), returnCode(-1),

stackSize(0), priority(QThread::InheritPriority), data(d)

{

...

if (!data)

data = new QThreadData;

}

QThread::QThread(QObject *parent)

: QObject(*(new QThreadPrivate), parent)

{

Q_D(QThread);

// fprintf(stderr, "QThreadData %p created for thread %p\n", d->data, this);

d->data->thread = this;

}

可以看到，当新建一个QThread时，二话不说它先是建立了一个新的QThreadData，并设置thread为自己。和QThreadData::current不同的是，QThreadData::current是被动生成一个QThreadData，因为它并没有指定某个QThread。而创建QThread则可以“名正言顺”创建QThreadData，然后将它的thread设置为自己。由于它还没有执行，因此并没有设置TLS。

当一个QThread要开始执行后：

void QThread::start(Priority priority)

{

...

d->handle = (Qt::HANDLE) _beginthreadex(NULL, d->stackSize, QThreadPrivate::start,

this, CREATE_SUSPENDED, &(d->id));

...

}

unsigned int __stdcall QThreadPrivate::start(void *arg)

{

QThread *thr = reinterpret_cast<QThread *>(arg);

QThreadData *data = QThreadData::get2(thr);

qt_create_tls();

TlsSetValue(qt_current_thread_data_tls_index, data);

...

data->quitNow = false;

// ### TODO: allow the user to create a custom event dispatcher

createEventDispatcher(data);

...

}

可以看到，TLS被设置成了刚刚QThread创建的QThreadData实例，那么之后在这个线程中，QThreadData::current就可以取到对应的信息了。它紧接着创建了event dispatcher，也就是QEventDispatcherWin32，并且塞给了QThreadData，保证这个线程中的消息循环都是通过此QEventDispatcherWin32。

需要注意的是，如果不是通过QThread创建的QThreadData(即通过QThreadData::current来创建的)默认是没有event dispatcher的，所以你无法对一个孤立的QObject分发事件。QCoreApplication并没有继承QThread，它通过QThreadData::current获取了实例后自己设置了event dispatcher来实现消息的分发。

这样一来一切都说得通了，为什么事件是跟着线程走的，为什么每个线程都有独立的消息循环，为什么需要moveToThread，一切原因，都在QThreadData里。

4. QWidget消息循环

刚刚看到每一个QEventDispatcherWin32都会创建一个隐藏的窗口来处理WMTIMER等事件，对于普通的QWidget来说，它们的消息处理函数叫做QtWndProc，定义在了qapplicationwin.cpp中。它里面无非就是将拿到的HWND映射到正确的QWidget中，然后翻译成Qt事件。Qt很巧妙地将QWidget强行转换为了QETWidget，实现了私有成员的封装，不过这个就已经超过我们讨论的范畴了。

以上便是Qt消息循环和线程相关的秘密，虽然Qt5的代码还没有仔细研究过，但是大体上变化应该不大，希望大家看完后，能对Qt有一个【卧槽好屌啊】这样的感受。