Qt 线程

高亚奇

已于 2024-03-18 13:57:49 修改

阅读量841

点赞数 14

分类专栏： # QT 线程文章标签： qt

于 2023-12-14 09:31:43 首次发布

本文链接：https://blog.csdn.net/m0_73482095/article/details/134987164

版权

QT 线程专栏收录该内容

2 篇文章 0 订阅

订阅专栏

启动线程的两种方式

Qt提供了一个与平台无关的QThread类，用以对线程的支持。多线程编程也可以有效解决在不冻结一个应用程序的用户界面情况下执行一个耗时的操作问题。对应本节的内容，可以在帮助中査看Thread Support in Qt关键字。

这里准备介绍QThread常用函数和启动线程的两种方式：

子类化
使用worker-object通过QObject::moveToThread将它们移动到线程中

一、QThread常用函数

可以将常用的函数按照功能进行以下分类：

线程启动
- void start()
  
  调用后会执行run()函数，但在run()函数执行前会发射信号started()，操作系统将根据优先级参数调度线程。如果线程已经在运行，那么这个函数什么也不做。优先级参数的效果取决于操作系统的调度策略。
线程执行
- int exec()
  
  每一个线程可以有自己的事件循环，可以通过调用exec()函数来启动事件循环。
- void run()
  
  线程的起点，在调用start()之后，新创建的线程就会调用这个函数，默认实现调用exec()，大多数需要重新实现这个函数，便于管理自己的线程。该函数返回后，线程便执行结束，就像应用程序离开main()函数一样。
线程退出
- void quit()
  
  使线程退出事件循环，返回0表示成功，相当于调用了QThread::exit(0)。
- void exit(int returnCode = 0)
  
  使线程退出事件循环，返回0表示成功，任何非0值表示失败。
- void terminate()
  
  在极端情况下，可能想要强制终止一个正在执行的线程，这时可以使用terminate()函数。但是，线程可能会立即被终止也可能不会，这取决于操作系统的调度策略，使用terminate()之后再使用QThread::wait()，以确保万无一失。
  
  警告：使用terminate()函数，线程可能在任何时刻被终止而无法进行一些淸理工作，因此该函数是很危险的，一般不建议使用，只有在绝对必要的时候使用。
- void requestInterruption()
  
  Qt5新引入接口，请求线程的中断，用于关闭线程。该请求是咨询意见并且取决于线程上运行的代码，来决定是否及如何执行这样的请求。此函数不停止线程上运行的任何事件循环，并且在任何情况下都不会终止它。
线程等待
- void msleep(unsigned long msecs) [static]
  
  强制当前线程睡眠msecs毫秒。
- void sleep(unsigned long secs) [static]
  
  强制当前线程睡眠secs秒。
- void usleep(unsigned long usecs) [static]
  
  强制当前线程睡眠usecs微秒。
- bool wait(unsigned long time = ULONG_MAX)
  
  线程将会被阻塞，等待time毫秒。和sleep不同的是，如果线程退出，wait会返回。
线程状态
- bool isFinished() const
  
  判断线程是否结束
- bool isRunning() const
  
  判断线程是否正在运行
- bool isInterruptionRequested() const
  如果线程上的任务运行应该停止，返回true；可以使用requestInterruption()请求中断。 Qt5新引入接口，用于使长时间运行的任务干净地中断。从不检查或作用于该函数返回值是安全的，但是建议在长时间运行的函数中经常这样做。注意：不要过于频繁调用，以保持较低的开销。示例程序如下：
```
void run() 
{
	// 是否请求终止
	while (!isInterruptionRequested())
	{
		// 耗时操作
	}
}
```
线程优先级
- void setPriority(Priority priority)
  
  设置正在运行线程的优先级。如果线程没有运行，此函数不执行任何操作并立即返回。使用的start()来启动一个线程具有特定的优先级。优先级参数可以是QThread::Priority枚举除InheritPriortyd的任何值。

枚举QThread::Priority：

常量	值	描述
QThread::IdlePriority	0	没有其它线程运行时才调度
QThread::LowestPriority	1	比LowPriority调度频率低
QThread::LowPriority	2	比NormalPriority调度频率低
QThread::NormalPriority	3	操作系统的默认优先级
QThread::HighPriority	4	比NormalPriority调度频繁
QThread::HighestPriority	5	比HighPriority调度频繁
QThread::TimeCriticalPriority	6	尽可能频繁的调度
QThread::InheritPriority	7	使用和创建线程同样的优先级. 这是默认值

二、子类化QThread方式启动线程

一个QThread代表了一个在应用程序中可以独立控制的线程，它与进程中的其他线程分享数据，但是是独立执行的。相对于一般的程序都是从main()函数开始执行，QThread从main()函数开始执行。默认的，run()通过调用exec()来开启事件循环。要创建一个线程，需要子类化QThread并且重新实现run()函数。例如：

class MyThread : public QThread
{
protected:
    void run();
};

void MyThread::run()
{
    QTcpSocket socket;
	...
    socket connectToHost(hostName, portNumber);
    exec();
}

这样会在一个线程中创建一个QTcpSocket，然后执行这个线程的事件循环。可以在外部创建该线程的实例，然后调用start()函数来开始执行该线程，start()默认会调用run()函数。当从run()函数返回后，线程便执行结束。

注意，在线程中是无法使用任何的部件类的。

实例程序

下面来看一个在图形界面程序中启动一个线程的例子，在界面上有两个按钮，一个用于开启一个线程，一个用于关闭该线程。新建Qt Gui应用，名称为myThread，类名为Dialog，基类选择QDialog。完成后进入设计模式，向界面中放人两个Push Button按钮，将第一个按钮的显示文本更改为“启动线程”，名称更改为startButton；将第二个按钮的显示文本更改为 “终止线程”，名称更改为stopButton，将其enabled属性取消选中。然后向项目中添加新的C++类，类名设置为“MyThread”，基类设置为“QThread”，类型信息选择“继承自QObject”。完成后进入mythread.h文件，修改如下：

#ifndef MYTHREAD_H
#define MYTHREAD_H

#include <QThread>

class MyThread : public QThread
{
    Q_OBJECT
public:
    explicit MyThread(QObject *parent = 0);
    void stop();

protected:
    void run();

private:
    volatile bool stopped;
};

#endif // MYTHREAD_H

这里stopped变量使用了volatile关键字，这样可以使它在任何时候都保持最新的值，从而可以避免在多个线程中访问它时出错。然后进入mythread.cpp文件中，修改如下：

#include "mythread.h"
#include <QDebug>

MyThread::MyThread(QObject *parent) :
    QThread(parent)
{
    stopped = false;
}

void MyThread::run()
{
    qreal i = 0;
    while (!stopped) 
    {
        qDebug() << QString("in MyThread: %1").arg(i);
        msleep(1000);
        i++;
    }
    stopped = false;
}

void MyThread::stop()
{
    stopped = true;
}

（1）构造函数中将stopped变量初始化为false。

（2）run()函数中一直判断stopped变量的值，只要它为false，那么每过1秒就一直打印i值递增的字符串。

（3）top()函数中将stopped变量设置为了true，这样便可以结束run()函数中的循环，从而从run()函数中退出，这样整个线程也就结束了。这里使用了stopped变量来实现了进程的终止，并没有使用危险的terminate()函数，也没有在析构函数中使用quit()、wait()和requestInterruption()函数。

下面在Dialog类中使用自定义的线程。先到dialog.h文件中，添加头文件"mythread.h"，然后添加私有对象：

#include "mythread.h"
...
private:    
	MyThread thread;

下面到设计模式，分别进入两个按钮的单击信号对应的槽，更改如下：

// 启动线程按钮
void Dialog::on_startButton_clicked()
{
    thread.start();
    ui->startButton->setEnabled(false);
    ui->stopButton->setEnabled(true);
}

// 终止线程按钮
void Dialog::on_stopButton_clicked()
{
    if (thread.isRunning())
    {
        thread.stop();
        ui->startButton->setEnabled(true);
        ui->stopButton->setEnabled(false);
    }
}

启动线程时调用了start()函数，然后设置了两个按钮的状态。在终止线程时，先使用isRunning()来判断线程是否在运行，如果是，则调用stop()函数来终止线程，并且更改两个按钮的状态。现在运行程序，单击“启动线程”按钮，査看应用程序输出栏的输出，然后再按下“终止线程”按钮，可以看到已经停止输出了。

三、worker-object方式启动线程

还有一种创建线程的方法，就是使用worker-object通过QObject::moveToThread将它们移动到线程中。例如：

//Worker类：在线程中执行的类，例如定时器超时操作
class Worker类 : public QObject
{
    Q_OBJECT

public slots:
    void doWork(const QString &parameter) 
    {
        QString result;
        // 这里是阻塞的操作
        emit resultReady(result);
    }

signals:
    void resultReady(const QString &result);
};

//Controller类：线程所在的类
class Controller : public QObject
{
    Q_OBJECT
    QThread workerThread;
    
public:
    Controller() 
    {
        Worker *worker = new Worker;
        //将worker对象的线程从主线程移动到workerThread
        worker->moveToThread(&workerThread);
        //当workerThread线程结束后，会自动销毁该线程
        connect(&workerThread, &QThread::finished, worker, &QObject::deleteLater);
        
        //当Controller类发射了operate()信号，会调用worker对象的doWork槽函数
        connect(this, &Controller::operate, worker, &Worker::doWork);
        //当workerr类发射了resultReady()信号，会调用Controller对象的handleResults槽函数
        connect(worker, &Worker::resultReady, this, &Controller::handleResults);
        
        //最开始，启动workerThread线程
        workerThread.start();
    }
    
    ~Controller() 
    {
    	//在析构函数中终止进程
    	workerThread.requestInterruption();
        workerThread.quit();
        workerThread.wait();
    }
    
public slots:
    void handleResults(const QString &);
    
signals:
    void operate(const QString &);
};

这样Worker槽中的代码将在一个单独的线程中执行，使用这种方式可以很容易地将一些费时的操作放到单独的工作线程中来完成。可以将任意线程中任意对象的任意一个信号关联到Worker的槽上，不同线程间的信号和槽进行关联是安全的。

四、关闭线程

关闭线程有多种方法，这里介绍一种最常用的方法：在析构函数中使用quit()、wait()和requestInterruption()函数。示例程序如下：

~WorkerThread() 
{
	// 请求终止
	requestInterruption();
	quit();
	wait();
}

线程与定时器

一、定时器QTimer类

The QTimer class provides repetitive and single-shot timers.

The QTimer class provides a high-level programming interface for timers. To use it, create a QTimer, connect its timeout() signal to the appropriate slots, and call start(). From then on, it will emit the timeout() signal at constant intervals.

上面这段话摘自Qt助手文档，我们使用QTimer类定义一个定时器，它可以不停重复，也可以只进行一次便停止。

使用起来也很简单：

QTimer *timer = new QTimer(this);

connect(timer, SIGNAL(timeout()), this, SLOT(update()));

timer->start(1000);

创建一个QTimer对象，将信号timeout()与相应的槽函数相连，然后调用start()函数。接下来，每隔一段时间，定时器便会发出一次timeout()信号。

更多用法这里就不讲了，您可以自行参考官方文档。比如如何停止、如何令定时器只运行一次等。

二、在多线程中使用QTimer

1.错误用法

您可能会这么做：

子类化QThread，在线程类中定义一个定时器，然后在run()方法中调用定时器的start()方法。

TestThread::TestThread(QObject *parent)

: QThread(parent)

{

m_pTimer = new QTimer(this);

connect(m_pTimer, &QTimer::timeout, this, &TestThread::timeoutSlot);

}

void TestThread::run()

{

m_pTimer->start(1000);

}

void TestThread::timeoutSlot()

{

qDebug() << QString::fromLocal8Bit("当前线程id：") << QThread::currentThread();

}

接下来在主线程中创建该线程对象，并调用它的start()方法：

m_pThread = new TestThread(this);

m_pThread->start();

看似十分自然，没有什么不妥，然而，编译器将通知下面的错误信息：

QObject::startTimer: Timers cannot be started from another thread

——定时器不能被其它线程start。

我们来分析一下：

刚开始只有主线程一个，TestThread的实例是在主线程中创建的，定时器在TestThread的构造函数中，所以也是在主线程中创建的。

当调用TestThread的start()方法时，这时有两个线程。定时器的start()方法是在另一个线程中，也就是TestThread中调用的。

创建和调用并不是在同一线程中，所以出现了错误。

每个QObject实例都有一个叫做“线程关系”(thread affinity)的属性，或者说，它处于某个线程中。

默认情况下，QObject处于创建它的线程中。

当QObject接收队列信号(queued signal)或者传来的事件(posted event)，槽函数或事件处理器将在对象所处的线程中执行。

根据以上的原理，Qt使用计时器的线程关系(thread affinity)来决定由哪个线程发出timeout()信号。正因如此，你必须在它所处的线程中start或stop该定时器，在其它线程中启动定时器是不可能的。

2.正确用法一

在TestThread线程启动后创建定时器。

void TestThread::run()

{

m_pTimer = new QTimer();

m_pTimer->setInterval(1000);

connect(m_pTimer, &QTimer::timeout, this, &TestThread::timeoutSlot);

m_pTimer->start();

this->exec();

}

有些地方需要注意：

1.不能像下面这样给定时器指定父对象

m_pTimer = new QTimer(this);

否则会出现以下警告：

QObject: Cannot create children for a parent that is in a different thread.

(Parent is TestThread(0x709d88), parent's thread is QThread(0x6e8be8), current thread is TestThread(0x709d88)　

因为TestThread对象是在主线程中创建的，它的QObject子对象也必须在主线程中创建。所以不能指定父对象为TestThread。

2.必须要加上事件循环exec()

否则线程会立即结束，并发出finished()信号。

另外还有一点需要注意，与start一样，定时器的stop也必须在TestThread线程中，否则会出错。

void TestThread::timeoutSlot()

{

m_pTimer->stop();

qDebug() << QString::fromLocal8Bit("当前线程id：") << QThread::currentThread();

}

上面的代码将出现以下错误：

QObject::killTimer: Timers cannot be stopped from another thread

综上，子类化线程类的方法可行，但是不太好。

3.正确用法二

无需子类化线程类，通过信号启动定时器。

TestClass::TestClass(QWidget *parent)

    : QWidget(parent)

{

    m_pThread = new QThread(this);

    m_pTimer = new QTimer();

    m_pTimer->moveToThread(m_pThread);

    m_pTimer->setInterval(1000);

    connect(m_pThread, SIGNAL(started()), m_pTimer, SLOT(start()));

    connect(m_pTimer, &QTimer::timeout, this, &ThreadTest::timeOutSlot, Qt::DirectConnection);

    connect(m_pThread, &QThread::finished, this, &QObject::deleteLater);
    m_pThread->start();


}


void TestClass::timeOutSlot()
{
    qDebug() << QStringLiteral("当前线程id：") << QThread::currentThread();
}

通过moveToThread()方法改变定时器所处的线程，不要给定时器设置父类，否则该函数将不会生效。

在信号槽连接时，我们增加了一个参数——连接类型，先看看该参数可以有哪些值：

Qt::AutoConnection：默认值。如果接收者处于发出信号的线程中，则使用Qt::DirectConnection，否则使用Qt::QueuedConnection，连接类型由发出的信号决定。

Qt::DirectConnection：信号发出后立即调用槽函数，槽函数在发出信号的线程中执行。

Qt::QueuedConnection：当控制权返还给接收者信号的事件循环中时，开始调用槽函数。槽函数在接收者的线程中执行。

回到我们的例子，首先将定时器所处的线程改为新建的线程，然后连接信号槽，槽函数在定时器所处的线程中执行。

线程同步、可重入与线程安全

一、同步线程方法

使用线程的目的是允许代码并行运行，但是有时线程必须停止并等待其他线程。例如，如果两个线程试图同时写入相同的变量，结果是不确定的，所以需要同步线程。同步线程是一种保护共享资源等数据的常见的技术。迫使线程等待另一个的原则被称为互斥。

Qt 中的 QMutex、QReadWriteLock、QSemaphore 和 QWaitCondition 类提供了同步线程的方法。

QMutex提供了一个互斥锁（mutex），在任何时间至多有一个线程可以获得mutex。如果一个线程尝试获得 mutex，而此时 mutex 已经被锁住了，这个线程将会睡眠，直到现在获得mutex的线程对mutex进行解锁为止。互斥锁经常用于对共享数据（例如，可以同时被多个线程访问的数据）的访问进行保护。
QReadWriteLock即读-写锁，与QMutex很相似，只不过它将对共享数据的访问区分为“读”访问和“写”访问，允许多个线程同时对数据进行“读”访问。在可能的情况下使用QReadWriteLock代替QMutex，可以提高多线程程序的并发度。
QSemaphore即信号量，是QMutex的一般化，用来保护一定数量的相同的资源，而互斥锁mutex只能保护一个资源。
QWaitCondition即条件变量，允许一个线程在一些条件满足时唤醒其他的线程。一个或者多个线程可以被阻塞来等待一个QWaitCondition来设置一个用于wakeOne()或者wakeAll()的条件。使用wakeOneO可以唤醒一个随机选取的等待线程，而使用wakeAll()可以唤醒所有正在等待的线程。

二、可重入与线程安全

这里的术语“可重入性”和“线程安全”被用来标记类与函数，以表明它们如何被应用在多线程应用程序中。

一个线程安全的函数可以同时被多个线程调用，甚至调用者会使用共享数据也没有问题，因为对共享数据的访问是串行的。
一个可重入函数也可以同时被多个线程调用，但是每个调用者只能使用自己的数据。

因此，一个线程安全的函数总是可重入的，但一个可重入的函数并不一定是线程安全的。扩展开来，一个可重入的类，指的是它的成员函数可以被多个线程安全地调用，只要每个线程使用这个类的不同的对象。而一个线程安全的类，指的是它的成员函数能够被多线程安全地调用，即使所有的线程都使用该类的同一个实例也没有关系。

注意： Qt的一些类被设计为线程安全的，如果它们的目的是多线程。如果一个函数没有被标记为线程安全的或可重入的，它就不应该被不同的线程使用。如果一个类没有被标记为线程安全的或可重入的，该类的实例就不应该被多个线程访问。

可重入性

C++的类往往是可重入的，这只是因为它们只能访问自己的数据。任何线程都能访问一个可重入类实例的一个成员函数，只要同一时间没有其它线程调用该实例的成员函数。例如，下面的Counter类就是可重入的：

class Counter
{
public:
    Counter() { n = 0; }

    void increment() { ++n; }
    void decrement() { --n; }
    int value() const { return n; }

private:
    int n;
};

该类不是线程安全的，因为如果多个线程试图修改数据成员n，则结果是不确定的。这是因为++和–操作都不总是原子性的。事实上，它们一般被展开为3条机器指令：

将变量值装入寄存器
增加或减少寄存器中的值
将寄存器中的值写回内存

如果线程A和线程B同时将变量的旧值装入寄存器，增加寄存器中的值，再写回内存，它们最终会互相覆盖，导致变量值仅增加了一次！

线程安全

显然，访问应该是串行的：线程A必须在无中断的情况下执行完1.2.3.三个步骤（原子性），然后线程B才能开始执行，反之亦然。一个使类是线程安全的简单方法就是用一个QMutex来保护数据成员的所有访问。

class Counter
{
public:
    Counter() { n = 0; }

    void increment() { QMutexLocker locker(&mutex); ++n; }
    void decrement() { QMutexLocker locker(&mutex); --n; }
    int value() const { QMutexLocker locker(&mutex); return n; }

private:
    mutable QMutex mutex;
    int n;
};

QMutexLocker类在其构造函数中自动锁定mutex，并且当析构函数被调用时解锁。锁定mutex保证了其它线程的访问都将是串行化的。mutex数据成员被声明为mutable的，这是因为value()是一个const函数，我们需要在其中lock和unlock该mutex。

Qt类的注意事项

许多Qt的类都是可重入的，但不是线程安全的，因为线程安全意味着为锁定与解锁一个QMutex增加额外的开销。例如：QString是可重入的，但不是线程安全的。你能够同时从多个线程访问不同的QString的实例，但不能同时从多个线程访问QString的同一个实例（除非用QMutex保护访问）。

有些Qt的类和函数是线程安全的。它们主要是线程相关类（例如：QMutex）和一些基本函数（例如： QCoreApplication::postEvent()）。

线程实际应用

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

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

一、多线程操作UI界面的示例

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

首先创建QtGui应用，工程名称为“myThreadBar”，类名选择“QMainWindow”，其他选项保持默认即可。再添加一个名称为WorkerThread的头文件，定义一个WorkerThread类，让其继承自QThread，并重写run()函数，修改workerthread.h文件如下：

#ifndef WORKERTHREAD_H
#define WORKERTHREAD_H

#include <QThread>
#include <QDebug>

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

#endif // WORKERTHREAD_H

通过在run()函数中调用msleep(50)，线程会每隔50毫秒让当前的进度值加1，然后发射一个resultReady()信号，其余时间什么都不做。在这段空闲时间，线程不占用任何的系统资源。当休眠时间结束，线程就会获得CPU时钟，将继续执行它的指令。

再在mainwindow.ui上添加一个按钮和进度条部件，然后mainwindow.h修改如下：

#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>
#include "workerthread.h"

namespace Ui {
class MainWindow;
}

class MainWindow : public QMainWindow
{
    Q_OBJECT

public:
    explicit MainWindow(QWidget *parent = nullptr);
    ~MainWindow();

private slots:
    // 更新进度
    void handleResults(int value);

    // 开启线程
    void startThread();

private:
    Ui::MainWindow *ui;

    WorkerThread m_workerThread;
};

#endif // MAINWINDOW_H

然后mainwindow.cpp修改如下：

#include "mainwindow.h"
#include "ui_mainwindow.h"

MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow)
{
    ui->setupUi(this);
        
	qDebug() << "Main Thread : " << QThread::currentThreadId();        

    // 连接信号槽
    this->connect(ui->pushButton, SIGNAL(clicked(bool)), this, SLOT(startThread()));
}

MainWindow::~MainWindow()
{
    delete ui;
}

void MainWindow::handleResults(int value)
{
    qDebug() << "Handle Thread : " << QThread::currentThreadId();
    ui->progressBar->setValue(value);
}

void MainWindow::startThread()
{
    WorkerThread *workerThread = new WorkerThread(this);
    this->connect(workerThread, SIGNAL(resultReady(int)), this, SLOT(handleResults(int)));
    // 线程结束后，自动销毁
    this->connect(workerThread, SIGNAL(finished()), workerThread, SLOT(deleteLater()));
    workerThread->start();
}

由于信号与槽连接类型默认为“Qt::AutoConnection”，在这里相当于“Qt::QueuedConnection”。也就是说，槽函数在接收者的线程（主线程）中执行。

执行程序，“应用程序输出”窗口输出如下：

Main Thread :  0x3140
Worker Thread :  0x3140
Worker Run Thread :  0x2588
Handle Thread :  0x3140

显然，UI界面、Worker构造函数、槽函数处于同一线程（主线程），而run()函数处于另一线程（次线程）。

二、避免多次connect

当多次点击“开始”按钮的时候，就会多次connect()，从而启动多个线程，同时更新进度条。为了避免这个问题，我们先在mainwindow.h上添加私有成员变量"WorkerThread m_workerThread;"，然后修改mainwindow.cpp如下：

#include "mainwindow.h"
#include "ui_mainwindow.h"

MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow)
{
    ui->setupUi(this);

    // 连接信号槽
    this->connect(ui->pushButton, SIGNAL(clicked(bool)), this, SLOT(startThread()));

    this->connect(&m_workerThread, SIGNAL(resultReady(int)), this, SLOT(handleResults(int)));
}

MainWindow::~MainWindow()
{
    delete ui;
}

void MainWindow::handleResults(int value)
{
    qDebug() << "Handle Thread : " << QThread::currentThreadId();
    ui->progressBar->setValue(value);
}

void MainWindow::startThread()
{
    if (!m_workerThread.isRunning())
        m_workerThread.start();
}

不再在startThread()函数内创建WorkerThread对象指针，而是定义私有成员变量，再将connect添加在构造函数中，保证了信号槽的正常连接。在线程start()之前，可以使用isFinished()和isRunning()来查询线程的状态，判断线程是否正在运行，以确保线程的正常启动。

三、优雅地结束线程的两种方法

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

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

QThread: Destroyed while thread is still running

这是因为次线程还在运行，就结束了UI主线程，导致事件循环结束。这个问题在使用线程的过程中经常遇到，尤其是耗时操作。大多数情况下，当程序退出时，次线程也许会正常退出。这时，虽然抱着侥幸心理，但隐患依然存在，也许在极少数情况下，就会出现Crash。

所以，我们应该采取合理的措施来优雅地结束线程，一般思路：

发起线程退出操作，调用quit()或exit()。
等待线程完全停止，删除创建在堆上的对象。
适当的使用wait()（用于等待线程的退出）和合理的算法。

方法一

这种方式是Qt4.x中比较常用的，主要是利用“QMutex互斥锁 + bool成员变量”的方式来保证共享数据的安全性。在workerthread.h上继续添加互斥锁、析构函数和stop()函数，修改如下：

#ifndef WORKERTHREAD_H
#define WORKERTHREAD_H

#include <QThread>
#include <QMutexLocker>
#include <QDebug>

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

#endif // WORKERTHREAD_H

当主窗口被关闭，其“子对象”WorkerThread也会析构调用stop()函数，使m_bStopped变为true，则break跳出循环结束run()函数，结束进程。当主线程调用stop()更新m_bStopped的时候，run()函数也极有可能正在访问它（这时，他们处于不同的线程），所以存在资源竞争，因此需要加锁，保证共享数据的安全性。

为什么要加锁？

很简单，是为了共享数据段操作的互斥。避免形成资源竞争的情况（多个线程有可能访问同一共享资源的情况）。

方法二

Qt5以后，可以使用requestInterruption()、isInterruptionRequested()这两个函数，使用很方便，修改workerthread.h文件如下：

#ifndef WORKERTHREAD_H
#define WORKERTHREAD_H

#include <QThread>
#include <QMutexLocker>
#include <QDebug>

class WorkerThread : public QThread
{
    Q_OBJECT

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

    ~WorkerThread()
    {
        // 请求终止
        requestInterruption();
        quit();
        wait();
    }

protected:
    virtual void run() Q_DECL_OVERRIDE
    {
        qDebug() << "Worker Run Thread : " << QThread::currentThreadId();
        int nValue = 0;

        // 是否请求终止
        while (!isInterruptionRequested())
        {
            while (nValue < 100)
            {
                // 休眠50毫秒
                msleep(50);
                ++nValue;

                // 准备更新
                emit resultReady(nValue);
            }
        }

    }
signals:
    void resultReady(int value);
};

#endif // WORKERTHREAD_H

在耗时操作中使用isInterruptionRequested()来判断是否请求终止线程，如果没有，则一直运行；当希望终止线程的时候，调用requestInterruption()即可。这两个函数内部也使用了互斥锁QMutex。

高亚奇

关注

14
点赞
踩
16

收藏

觉得还不错? 一键收藏
打赏
0
评论
Qt 线程

当主线程调用stop()更新m_bStopped的时候，run()函数也极有可能正在访问它（这时，他们处于不同的线程），所以存在资源竞争，因此需要加锁，保证共享数据的安全性。在终止线程时，先使用isRunning()来判断线程是否在运行，如果是，则调用stop()函数来终止线程，并且更改两个按钮的状态。因此，一个线程安全的函数总是可重入的，但一个可重入的函数并不一定是线程安全的。扩展开来，一个可重入的类，指的是它的成员函数可以被多个线程安全地调用，只要每个线程使用这个类的不同的对象。
复制链接

扫一扫