本章會挑出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版本）不是抽象類，

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/205564.html

標籤：C++

上一篇：Oracle中常用函式