【QT】QThread源碼淺析

本章會挑出QThread源碼中部分重點代碼來說明QThread啟動到結束的過程是怎麼排程的。其次因為到了Qt4.4版本，Qt的多線程就有所變化，是以本章會以Qt4.0.1和Qt5.6.2版本的源碼來進行淺析。

一、QThread類的定義源碼

Qt4.0.1版本源碼：

#ifndef QT_NO_THREAD
class Q_CORE_EXPORT QThread : public QObject
{
public:
    ...//省略
    explicit QThread(QObject *parent = 0);
    ~QThread();
    ...//省略
    void exit(int retcode = 0);

public slots:
    void start(QThread::Priority = InheritPriority); //啟動線程函數
    void terminate(); //強制退出線程函數
    void quit(); //線程退出函數
    ...//省略
signals:
    void started(); //線程啟動信号
    void finished(); //線程結束信号
    ...//省略
    
protected:
    virtual void run() = 0;
    int exec();
    ...//省略
};
#else // QT_NO_THREAD

Qt5.6.2版本源碼：

#ifndef QT_NO_THREAD
class Q_CORE_EXPORT QThread : public QObject
{
    Q_OBJECT
public:
    ...//省略
    explicit QThread(QObject *parent = Q_NULLPTR);
    ~QThread();
    ...//省略
    void exit(int retcode = 0); //線程退出函數
    ...//省略
public Q_SLOTS:
    void start(Priority = InheritPriority); //啟動線程函數
    void terminate(); //強制退出線程函數
    void quit(); //線程退出函數
    ...//省略
Q_SIGNALS:
    void started(QPrivateSignal); //線程啟動信号
    void finished(QPrivateSignal); //線程結束信号
    
protected:
    virtual void run();
    int exec();
    ...//省略
};
#else // QT_NO_THREAD

從以上兩個版本的代碼可以看出，這些函數在聲明上基本沒什麼差異，但是仔細看，兩個版本的 run() 函數聲明的是不是不一樣？

Qt4.0.1版本run() 函數是純虛函數，即此類為抽象類不可以建立執行個體，隻可以建立指向該類的指針，也就是說如果你需要使用QThread來實作多線程，就必須實作QThread的派生類并且實作 run() 函數；
Qt5.6.2版本的run() 函數是虛函數，繼承QThread類時，可以重新實作 run() 函數，也可以不實作。

注：我檢視了多個Qt版本的源碼，發現出現以上差異的版本是從Qt4.4開始的。從Qt4.4版本開始，QThread類就不再是抽象類了。

二、QThread::start()源碼

再來看看QThread::start()源碼，Qt4.0.1版本和Qt5.6.2版本此部分的源碼大同小異，是以以Qt5.6.2版本的源碼為主，如下：

void QThread::start(Priority priority)
{
    Q_D(QThread);
    QMutexLocker locker(&d->mutex);
 
    if (d->isInFinish) {
        locker.unlock();
        wait();
        locker.relock();
    }
 
    if (d->running)
        return;
        
    ... ... // 此部分是d指針配置
 
#ifndef Q_OS_WINRT

    ... ... // 此部分為注釋
    
    d->handle = (Qt::HANDLE) _beginthreadex(NULL, d->stackSize, QThreadPrivate::start,
                                            this, CREATE_SUSPENDED, &(d->id));
#else // !Q_OS_WINRT
    d->handle = (Qt::HANDLE) CreateThread(NULL, d->stackSize, (LPTHREAD_START_ROUTINE)QThreadPrivate::start,
                                            this, CREATE_SUSPENDED, reinterpret_cast<LPDWORD>(&d->id));
#endif // Q_OS_WINRT
 
    if (!d->handle) {
        qErrnoWarning(errno, "QThread::start: Failed to create thread");
        d->running = false;
        d->finished = true;
        return;
    }
 
    int prio;
    d->priority = priority;
    switch (d->priority) {
    
    ... ... // 此部分為線程優先級配置
    
    case InheritPriority:
    default:
        prio = GetThreadPriority(GetCurrentThread());
        break;
    }
 
    if (!SetThreadPriority(d->handle, prio)) {
        qErrnoWarning("QThread::start: Failed to set thread priority");
    }
 
    if (ResumeThread(d->handle) == (DWORD) -1) {
        qErrnoWarning("QThread::start: Failed to resume new thread");
    }
}

挑出裡面的重點來說明：

（1）Q_D()宏定義

在看源碼的時候，當時比較好奇start函數的第一條語句 Q_D()宏定義是什麼意思，是以就看了下源碼，在此也順便講講，Q_D() 源碼是一個宏定義，如下：

#define Q_D(Class) Class##Private * const d = d_func()

此處利用了預處理宏裡的 ## 操作符：連接配接前後兩個符号，變成一個新的符号。将Q_D(QThread)展開後，變成：QThreadPrivate * const d = d_func()。

（2）_beginthreadex()函數

上面d->handle = (Qt::HANDLE) _beginthreadex ( NULL, d->stackSize, QThreadPrivate::start, this, CREATE_SUSPENDED, &( d->id ) ) 語句中的函數是建立線程的函數，其原型以及各參數的說明如下：

unsigned long _beginthreadex( 
 
void *security,       // 安全屬性，NULL為預設安全屬性
 
unsigned stack_size,  // 指定線程堆棧的大小。如果為0，則線程堆棧大小和建立它的線程的相同。一般用0
 
unsigned ( __stdcall *start_address )( void * ), 
                      // 指定線程函數的位址，也就是線程調用執行的函數位址(用函數名稱即可，函數名稱就表示位址)
 
void *arglist,        // 傳遞給線程的參數的指針，可以通過傳入對象的指針，線上程函數中再轉化為對應類的指針
                        //如果傳入this，這個this表示調用QThread::start的對象位址，也就是QThread或者其派生類對象本身
 
unsigned initflag,    // 線程初始狀态，0:立即運作；CREATE_SUSPEND：suspended（懸挂）
 
unsigned *thrdaddr    // 用于記錄線程ID的位址
 
);

三、QThreadPrivate::start()源碼

從QThread::start()源碼可以知道，QThreadPrivate::start是重點，其實際就是調用了QThreadPrivate::start(this)，這個 this 表示調用QThread::start的對象位址，也就是QThread或者其派生類對象本身。因為兩個Qt版本此部分的源碼大同小異，是以本部分主要是以5.6.2版本的源碼為主，其源碼以及說明如下：

// 參數arg就是上面所說的this
unsigned int __stdcall QT_ENSURE_STACK_ALIGNED_FOR_SSE QThreadPrivate::start(void *arg)
{
    QThread *thr = reinterpret_cast<QThread *>(arg);
    QThreadData *data = QThreadData::get2(thr);
 
    // 建立線程局部存儲變量，存放線程id
    qt_create_tls();
    TlsSetValue(qt_current_thread_data_tls_index, data);
    data->threadId = reinterpret_cast<Qt::HANDLE>(quintptr(GetCurrentThreadId()));
 
    QThread::setTerminationEnabled(false);
 
    {
        QMutexLocker locker(&thr->d_func()->mutex);
        data->quitNow = thr->d_func()->exited;
    }
 
    if (data->eventDispatcher.load()) // custom event dispatcher set?
        data->eventDispatcher.load()->startingUp();
    else
        createEventDispatcher(data);
        
    ...//省略
    
    emit thr->started(QThread::QPrivateSignal()); // 發射線程啟動信号
    QThread::setTerminationEnabled(true);
    thr->run(); // 調用QThread::run()函數 -- 線程函數
 
    finish(arg); //結束線程
    return 0;
}

由上述源碼可以看出，實際上 run() 函數是在這裡調用的，并且發出了 started() 啟動信号，等到 run() 函數執行完畢，最後是調用了 QThreadPrivate::finish 函數結束線程，并且在finish内會發出 QThread::finished() 線程已結束的信号。

四、QThread::run()源碼

再看看QThread::run()函數的源碼。在上面《2.1 QThread類的定義源碼》的小節，我們可以看到兩個Qt版本聲明此方法的方式不一樣，Qt-4.0版本将此定義為了純虛函數，而Qt-5.6版本将此定義為了虛函數，那我們就看看Qt-5.6版本中，QThread::run()是如何定義的，如下：

void QThread::run()
{
    (void) exec();
}

每一個 Qt 應用程式至少有一個事件循環，就是調用了 QCoreApplication::exec() 的那個事件循環。不過，QThread也可以開啟事件循環。隻不過這是一個受限于線程内部的事件循環。是以我們将處于調用main()函數的那個線程，并且由 QCoreApplication::exec() 建立開啟的那個事件循環成為主事件循環，或者直接叫主循環。注意，QCoreApplication::exec()隻能在調用main()函數的線程調用。主循環所在的線程就是主線程，也被成為 GUI 線程，因為所有有關 GUI 的操作都必須在這個線程進行。QThread的局部事件循環則可以通過在 QThread::run() 中調用 QThread::exec() 開啟。
我們通過以上源碼可以看到，它的定義很簡單，就是調用了一個函數：QThread::exec() 開啟線程中的事件循環，我們也可以通過繼承QThread，重寫run()函數的方式，讓其實作相對複雜的邏輯代碼。如果你的線程需要将某些槽函數在本線程完成的話，就必須開啟事件循環，否則線上程内無法響應各種信号并作出相應的行為。

小結：比Qt-4.4版本更早的版本中，我們使用QThread啟動線程時，就必須要實作繼承于QThread的派生類，并且一定要重寫run函數，若需要使用事件循環，就需要在run函數中添加exec()。到了Qt4.4版本之後（包括Qt4.4版本），QThread就不是抽象類了，不派生也可以執行個體化，在不重寫QThread::run()方法，start啟動線程是預設啟動事件循環的。

注：當程式跑到了exec()代碼時，位于exec()後面的代碼就不會再被執行，除非我們使用quit、exit等退出語句來退出事件循環，退出後，程式才會繼續執行位于exec()後面的代碼。

五、QThread::quit()、QThread::exit()、QThread::terminate()源碼

線程停止函數的差別，從Qt源碼來分析：

（1）QThread::quit()、QThread::exit()

//QThread::quit()聲明
void quit();
//QThread::quit()定義
void QThread::quit()
{ exit(); }

//QThread::exit()聲明
void exit(int retcode = 0);
//QThread::exit()定義
void QThread::exit(int returnCode)
{
    Q_D(QThread);
    QMutexLocker locker(&d->mutex);
    d->exited = true;
    d->returnCode = returnCode;
    d->data->quitNow = true;
    for (int i = 0; i < d->data->eventLoops.size(); ++i) {
        QEventLoop *eventLoop = d->data->eventLoops.at(i);
        eventLoop->exit(returnCode);
    }
}

由以上源碼可知，QThread::quit() 和 QThread::exit(0) 的調用是等效的，都是告訴線程的事件循環，以傳回碼0（成功）退出。如果線程沒有事件，則此函數不執行任何操作，也就是無效的。當線程擁有事件循環并且正處于事件循環（QThread::exec()）的狀态時，調用 QThread::quit()或者QThread::exit() 線程就會馬上停止，否則不會立刻停止線程，直到線程處于事件循環也就是正在執行 QThread::exec() 時，才會停止線程。

如果重複調用 QThread::quit()或者QThread::exit() 會有什麼影響嗎？

重複調用 QThread::quit()或者QThread::exit() 也不會有什麼影響，因為隻有擁有事件循環的線程，這兩個函數才會生效停止線程的功能。

（2）QThread::terminate()

void QThread::terminate()
{
    Q_D(QThread);
    QMutexLocker locker(&d->mutex);
    if (!d->running)
        return;
    if (!d->terminationEnabled) {
        d->terminatePending = true;
        return;
    }

// Calling ExitThread() in setTerminationEnabled is all we can do on WinRT
#ifndef Q_OS_WINRT
    TerminateThread(d->handle, 0);
#endif
    QThreadPrivate::finish(this, false); //結束線程函數
}

在這個函數定義的最後一個語句，是調用了 QThreadPrivate::finish(this, false); 函數，其函數作用是直接退出線程，無論線程是否開啟了事件循環都會生效，會馬上終止一個線程，但這個函數存在非常不安定因素，不推薦使用。

如果重複調用 QThread::terminate() 會有什麼影響嗎？

沒有影響。我們可以看到函數體裡面的第三條語句，它首先會判斷線程是否還在運作中，如果不是，會直接退出函數，就不會繼續往下執行調用QThreadPrivate::finish(this, false); 函數了。

六、章節小結

相信看了以上的一些QThread源碼，都大概知道了QThread類的本質以及QThread開啟到結束的過程。這裡我再簡單總結下：

（1）QThread的本質：

QThread 是用來管理線程的，它所依附的線程和它管理的線程并不是同一個東西；
QThread 所依附的線程，就是執行 QThread t 或 QThread * t=new QThread 所在的線程；
QThread 管理的線程，就是 run 啟動的線程，也就是次線程。

（2）在這裡針對Qt4.4版本之後（包括Qt4.4版本）簡單彙總一下線程啟動到結束的過程：

QThread對象或者QThread派生類對象顯式調用QThread類中的外部start()方法；
QThread::start()方法再調用QThreadPrivate::start()方法；
在QThreadPrivate::start()方法内調用了QThread::run()虛函數，對使用者來說到了這裡才是真正進入了一個新的線程裡面。也就是說定義QThread對象或者QThread派生類對象的時候，還是在原來的線程裡面，隻有進入run函數才是進入了新的線程；
在QThreadPrivate::start()方法調用QThread::run()虛函數結束後，就會繼續調用QThreadPrivate::finish()函數來結束線程，并發出線程結束的信号finished()。

（3）QThread::quit()、QThread::exit()、QThread::terminate()：

對線程重複使用這三個停止線程的函數，沒有任何影響；
盡量不要使用QThread::terminate()停止線程，此方式是強制退出線程，沒有安全保障。
調用QThread::quit()和QThread::exit()一樣。

（4）Qt各版本QThread類的變化：

Qt4.4版本之前QThread類是屬于抽象類， Qt4.4版本之後（包括4.4版本）不是抽象類。

【QT】QThread源碼淺析

一、QThread類的定義源碼

二、QThread::start()源碼

三、QThreadPrivate::start()源碼

四、QThread::run()源碼

五、QThread::quit()、QThread::exit()、QThread::terminate()源碼

六、章節小結

繼續閱讀

【QT】 QThread部分源碼淺析

【QT】子類化QObject+moveToThread實作多線程

【QT】繼承QRunnable+QThreadPool實作多線程

【QT】QtConcurrent::run()+QThreadPool實作多線程

【QT】跨線程的信号槽（connect函數）