簡述

為了讓程式儘快響應使用者操作，在開發應用程式時經常會使用到執行緒。對於耗時操作如果不使用執行緒，UI介面將會長時間處於停滯狀態，這種情況是使用者非常不願意看到的，我們可以用執行緒來解決這個問題。

前面，已經介紹了QThread常用的兩種方式：

• Worker-Object
• 子類化QThread

下面，我們來看看子類化QThread在日常中的應用。

|

大多數情況下，多執行緒耗時操作會與UI進行互動，比如：顯示進度、載入等待。。。讓使用者明確知道目前的狀態，並對結果有一個直觀的預期，甚至有趣巧妙的設計，能讓使用者愛上等待，把等待看成一件很美好的事。

子類化QThread

下面，是一個使用多執行緒操作UI介面的示例 - 更新進度條。與此同時，分享在此過程中有可能遇到的問題及解決方法。

定義一個WorkerThread類，讓其繼承自QThread，並重寫run()函式，每隔50毫秒更新當前值，然後發射resultReady()訊號（用於更新進度條）。

#include <QThread>

class WorkerThread : public QThread
{
    Q_OBJECT

public:
    explicit WorkerThread(QObject *parent = 0)
        : QThread(parent)
    {
        qDebug() << "Worker Thread : " << QThread::currentThreadId();
    }

protected
 
:
    virtual void run() Q_DECL_OVERRIDE {
        qDebug() << "Worker Run Thread : " << QThread::currentThreadId();
        int nValue = 0;
        while (nValue < 100)
        {
            // 休眠50毫秒
            msleep(50);
            ++nValue;

            // 準備更新
            emit resultReady(nValue);
        }
    }
signals:
    void
 
 resultReady(int value);
};

構建一個主介面 - 包含按鈕、進度條，當點選“開始”按鈕時，啟動執行緒，更新進度條。

class MainWindow : public CustomWindow
{
    Q_OBJECT

public:
    explicit MainWindow(QWidget *parent = 0)
        : CustomWindow(parent)
    {
        qDebug() << "Main Thread : " << QThread::currentThreadId();

        // 建立開始按鈕、進度條
        QPushButton *pStartButton = new QPushButton(this);
        m_pProgressBar = new QProgressBar(this);

        //設定文字、進度條取值範圍
        pStartButton->setText(QString::fromLocal8Bit("開始"));
        m_pProgressBar->setFixedHeight(25);
        m_pProgressBar->setRange(0, 100);
        m_pProgressBar->setValue(0);

        QVBoxLayout *pLayout = new QVBoxLayout();
        pLayout->addWidget(pStartButton, 0, Qt::AlignHCenter);
        pLayout->addWidget(m_pProgressBar);
        pLayout->setSpacing(50);
        pLayout->setContentsMargins(10, 10, 10, 10);
        setLayout(pLayout);

        // 連線訊號槽
        connect(pStartButton, SIGNAL(clicked(bool)), this, SLOT(startThread()));
    }

    ~MainWindow(){}

private slots:
    // 更新進度
    void handleResults(int value)
    {
        qDebug() << "Handle Thread : " << QThread::currentThreadId();
        m_pProgressBar->setValue(value);
    }

    // 開啟執行緒
    void startThread()
    {
        WorkerThread *workerThread = new WorkerThread(this);
        connect(workerThread, SIGNAL(resultReady(int)), this, SLOT(handleResults(int)));
        // 執行緒結束後，自動銷燬
        connect(workerThread, SIGNAL(finished()), workerThread, SLOT(deleteLater()));
        workerThread->start();
    }

private:
    QProgressBar *m_pProgressBar;
    WorkerThread m_workerThread;
};

顯然，UI介面、Worker建構函式、槽函式處於同一執行緒（主執行緒），而run()函式處於另一執行緒（次執行緒）。

Main Thread : 0x34fc
Worker Thread : 0x34fc
Worker Run Thread : 0x4038
Handle Thread : 0x34fc

由於訊號與槽連線型別預設為“Qt::AutoConnection”，在這裡相當於“Qt::QueuedConnection”。

也就是說，槽函式在接收者的執行緒（主執行緒）中執行。

注意：訊號與槽的連線型別，請參考：Qt之Threads和QObjects中“跨執行緒的訊號和槽”部分。

執行緒休眠

上述示例中，通過在run()函式中呼叫msleep(50)，執行緒會每隔50毫秒讓當前的進度值加1，然後發射一個resultReady()訊號，其餘時間什麼都不做。在這段空閒時間，執行緒不佔用任何的系統資源。當下一次CPU時鐘來臨時，它會繼續執行。

QThread提供了靜態的、平臺獨立的休眠函式：sleep()、msleep()、usleep()，允許秒，毫秒和微秒來區分，函式接受整型數值作為引數，以表明執行緒掛起執行的時間。當休眠時間結束，執行緒就會獲得CPU時鐘，將繼續執行它的指令。

想象一下，日常用的電腦，如果我們需要離開一段時間，可以將它設定為休眠狀態，為了節約用電，同時響應國家政策 - 走綠色、環保之道。

可以嘗試註釋掉休眠部分的程式碼，這時，由於沒有任何耗時操作，會造成頻繁地更新UI。所以，為了保證介面的流暢性，同時確保進度的更新在人眼可接受的範圍內，我們應在必要的時候加上適當時間的休眠。

在主執行緒中更新UI

當連線方式更改為“Qt::DirectConnection”時：

connect(workerThread, SIGNAL(resultReady(int)), this, SLOT(handleResults(int)), Qt::DirectConnection);

再次點選“開始”按鈕，會很失望，因為它會出現一個異常，描述如下：

ASSERT failure in QCoreApplication::sendEvent: “Cannot send events to objects owned by a different thread. Current thread e346e8. Receiver customWidget’ (of type ‘MainWindow’) was created in thread 4186a0”, file kernel\qcoreapplication.cpp, line 553

顯然，UI介面、Worker建構函式處於同一執行緒（主執行緒），而run()函式、槽函式處於同一執行緒（次執行緒）。

Main Thread : 0x2c6c
Worker Thread : 0x2c6c
Worker Run Thread : 0x4704
Handle Thread : 0x4704

之所以會出現這種情況是因為Qt做了限制（其它大多數GUI程式設計也一樣），不允許在其它執行緒（非主執行緒）中訪問UI控制元件，這麼做主要是怕在多執行緒環境下對介面控制元件進行操作會出現不可預知的情況。

所以，不難理解，由於在槽函式（次執行緒）中更新了UI，所以，會引起以上錯誤。

避免多次connect

當多次點選“開始”按鈕的時候，就會多次connect()，從而啟動多個執行緒，同時更新進度條。

為了避免這個問題，我們修改如下：

class MainWindow : public CustomWindow
{
    Q_OBJECT

public:
    explicit MainWindow(QWidget *parent = 0)
        : CustomWindow(parent)
    {
        // ...
        connect(&m_workerThread, SIGNAL(resultReady(int)), this, SLOT(handleResults(int)));
    }

    ~MainWindow(){}

private slots:
    // ...
    void startThread()
    {
        if (!m_workerThread.isRunning())
            m_workerThread.start();
    }

private:
    WorkerThread m_workerThread;
};

將connect新增在建構函式中，保證了訊號槽的正常連線。線上程start()之前，可以使用isFinished()和isRunning()來查詢執行緒的狀態，判斷執行緒是否正在執行，以確保執行緒的正常啟動。

優雅地結束執行緒

如果一個執行緒執行完成，就會結束。可很多情況並非這麼簡單，由於某種特殊原因，當執行緒還未執行完時，我們就想中止它。

不恰當的中止往往會引起一些未知錯誤。比如：當關閉主介面的時候，很有可能次執行緒正在執行，這時，就會出現如下提示：

QThread: Destroyed while thread is still running

這是因為次執行緒還在執行，就結束了UI主執行緒，導致事件迴圈結束。這個問題在使用執行緒的過程中經常遇到，尤其是耗時操作。

在此問題上，常見的兩種人：

• 直接忽略此問題。
• 強制中止 - terminate()。

大多數情況下，當程式退出時，次執行緒也許會正常退出。這時，雖然抱著僥倖心理，但隱患依然存在，也許在極少數情況下，就會出現Crash。

正如前面提到過terminate()，比較危險，不鼓勵使用。執行緒可以在程式碼執行的任何點被終止。執行緒可能在更新資料時被終止，從而沒有機會來清理自己，解鎖等等。。。總之，只有在絕對必要時使用此函式。

舉一個簡單的例子：當你的哥們正處於長時間的酣睡狀態時，你想要叫醒他，但是採取的措施卻是潑一盆涼水，想象一下後果？這涼爽 - O(∩_∩)O哈哈~。

所以，我們應該採取合理的措施來優雅地結束執行緒，一般思路：

1. 發起執行緒退出操作，呼叫quit()或exit()。
2. 等待執行緒完全停止，刪除建立在堆上的物件。
3. 適當的使用wait()（用於等待執行緒的退出）和合理的演算法。

下面介紹兩種方式：

• QMutex互斥鎖 + bool成員變數。

這種方式是Qt4.x中比較常用的，主要是利用“QMutex互斥鎖 + bool成員變數”的方式來保證共享資料的安全性（可以完全參照下面的requestInterruption()原始碼寫法）。

#include <QThread>
#include <QMutexLocker>

class WorkerThread : public QThread
{
    Q_OBJECT

public:
    explicit WorkerThread(QObject *parent = 0)
        : QThread(parent),
          m_bStopped(false)
    {
        qDebug() << "Worker Thread : " << QThread::currentThreadId();
    }

    ~WorkerThread()
    {
        stop();
        quit();
        wait();
    }

    void stop()
    {
        qDebug() << "Worker Stop Thread : " << QThread::currentThreadId();
        QMutexLocker locker(&m_mutex);
        m_bStopped = true;
    }

protected:
    virtual void run() Q_DECL_OVERRIDE {
        qDebug() << "Worker Run Thread : " << QThread::currentThreadId();
        int nValue = 0;
        while (nValue < 100)
        {
            // 休眠50毫秒
            msleep(50);
            ++nValue;

            // 準備更新
            emit resultReady(nValue);

            // 檢測是否停止
            {
                QMutexLocker locker(&m_mutex);
                if (m_bStopped)
                    break;
            }
            // locker超出範圍並釋放互斥鎖
        }
    }
signals:
    void resultReady(int value);

private:
    bool m_bStopped;
    QMutex m_mutex;
};

為什麼要加鎖？很簡單，是為了共享資料段操作的互斥。
何時需要加鎖？在形成資源競爭的時候，也就是說，多個執行緒有可能訪問同一共享資源的時候。

當主執行緒呼叫stop()更新m_bStopped的時候，run()函式也極有可能正在訪問它（這時，他們處於不同的執行緒），所以存在資源競爭，因此需要加鎖，保證共享資料的安全性。

• Qt5以後：requestInterruption() + isInterruptionRequested()

這兩個介面是Qt5.x引入的，使用很方便：

class WorkerThread : public QThread
{
    Q_OBJECT

public:
    explicit WorkerThread(QObject *parent = 0)
        : QThread(parent)
    {
    }

    ~WorkerThread() {
        // 請求終止
        requestInterruption();
        quit();
        wait();
    }

protected:
    virtual void run() Q_DECL_OVERRIDE {
        // 是否請求終止
        while (!isInterruptionRequested())
        {
            // 耗時操作
        }
    }
};

在耗時操作中使用isInterruptionRequested()來判斷是否請求終止執行緒，如果沒有，則一直執行；當希望終止執行緒的時候，呼叫requestInterruption()即可。

正如侯捷所言：「原始碼面前，了無祕密」。如果還心存疑慮，我們不妨來看看requestInterruption()、isInterruptionRequested()的原始碼：

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;
}

^_^，內部實現居然也用了互斥鎖QMutex，這樣我們就可以放心地使用了。

更多參考