Qt之QThread（深入理解）

ゝ一纸荒年。 2023-07-10 12:46 13阅读 0赞

# 简述 #

为了让程序尽快响应用户操作，在开发应用程序时经常会使用到线程。对于耗时操作如果不使用线程，UI界面将会长时间处于停滞状态，这种情况是用户非常不愿意看到的，我们可以用线程来解决这个问题。

前面，已经介绍了QThread常用的两种方式：

*  Worker-Object
 *  子类化QThread

下面，我们来看看子类化QThread在日常中的应用。

*  [简述][Link 1]
 *  [子类化QThread][QThread]
 *  [线程休眠][Link 2]
 *  [在主线程中更新UI][UI]
 *  [优雅地结束线程][Link 3]
 *  [更多参考][Link 4]

大多数情况下，多线程耗时操作会与UI进行交互，比如：显示进度、加载等待。。。让用户明确知道目前的状态，并对结果有一个直观的预期，甚至有趣巧妙的设计，能让用户爱上等待，把等待看成一件很美好的事。

# 子类化QThread #

下面，是一个使用多线程操作UI界面的示例 - 更新进度条。与此同时，分享在此过程中有可能遇到的问题及解决方法。

![这里写图片描述][20160811210805696]

定义一个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][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，所以，会引起以上错误。

#  #

# 优雅地结束线程 #

如果一个线程运行完成，就会结束。可很多情况并非这么简单，由于某种特殊原因，当线程还未执行完时，我们就想中止它。

不恰当的中止往往会引起一些未知错误。比如：当关闭主界面的时候，很有可能次线程正在运行，这时，就会出现如下提示：

> 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，这样我们就可以放心地使用了

[Link 1]: https://blog.csdn.net/weixin_34194359/article/details/90525009?depth_1-utm_source=distribute.pc_relevant.none-task&utm_source=distribute.pc_relevant.none-task#%E7%AE%80%E8%BF%B0
[QThread]: https://blog.csdn.net/weixin_34194359/article/details/90525009?depth_1-utm_source=distribute.pc_relevant.none-task&utm_source=distribute.pc_relevant.none-task#%E5%AD%90%E7%B1%BB%E5%8C%96qthread
[Link 2]: https://blog.csdn.net/weixin_34194359/article/details/90525009?depth_1-utm_source=distribute.pc_relevant.none-task&utm_source=distribute.pc_relevant.none-task#%E7%BA%BF%E7%A8%8B%E4%BC%91%E7%9C%A0
[UI]: https://blog.csdn.net/weixin_34194359/article/details/90525009?depth_1-utm_source=distribute.pc_relevant.none-task&utm_source=distribute.pc_relevant.none-task#%E5%9C%A8%E4%B8%BB%E7%BA%BF%E7%A8%8B%E4%B8%AD%E6%9B%B4%E6%96%B0ui
[Link 3]: https://blog.csdn.net/weixin_34194359/article/details/90525009?depth_1-utm_source=distribute.pc_relevant.none-task&utm_source=distribute.pc_relevant.none-task#%E4%BC%98%E9%9B%85%E5%9C%B0%E7%BB%93%E6%9D%9F%E7%BA%BF%E7%A8%8B
[Link 4]: https://blog.csdn.net/weixin_34194359/article/details/90525009?depth_1-utm_source=distribute.pc_relevant.none-task&utm_source=distribute.pc_relevant.none-task#%E6%9B%B4%E5%A4%9A%E5%8F%82%E8%80%83
[20160811210805696]: https://img-blog.csdn.net/20160811210805696
[Qt_Threads_QObjects]: http://blog.csdn.net/liang19890820/article/details/52054152