QThread的用法

最新推荐文章于 2024-10-12 17:06:02 发布

延卿

最新推荐文章于 2024-10-12 17:06:02 发布

阅读量480

点赞数

分类专栏： c++

c++ 专栏收录该内容

176 篇文章 4 订阅

订阅专栏

概述

QThread类提供了一个与平台无关的管理线程的方法。一个QThread对象管理一个线程。QThread的执行从run()函数的执行开始，在Qt自带的QThread类中，run()函数通过调用exec()函数来启动事件循环机制，并且在线程内部处理Qt的事件。在Qt中建立线程的主要目的就是为了用线程来处理那些耗时的后台操作，从而让主界面能及时响应用户的请求操作。QThread的使用方法有如下两种：

QObject::moveToThread()
继承QThread类

下面通过具体的方法描述和例子来介绍两种方法。

方法一. QObject::moveToThread()方法

方法描述

定义一个继承于QObject的worker类，在worker类中定义一个槽slot函数doWork()，这个函数中定义线程需要做的工作。
在要使用线程的controller类中，新建一个QThread的对象和woker类对象，使用moveToThread()方法将worker对象的事件循环全部交由QThread对象处理。
建立相关的信号函数和槽函数进行连接，然后发出信号触发QThread的槽函数，使其执行工作。

moveToThread的例子

首先新建一个work类，该类重点在于其doWork槽函数，这个函数定义了线程需要做的工作，需要向其发送信号来触发。Wrok类的头文件中定义了全部函数，其cpp文件为空，因此就不贴出来了。

Wroker.h

//work定义了线程要执行的工作
#ifndef WORKER_H
#define WORKER_H
#include <QObject>
#include<QDebug>
#include<QThread>
class Worker:public QObject
{
    Q_OBJECT
public:
    Worker(QObject* parent = nullptr){}
public slots:
        //doWork定义了线程要执行的操作
    void doWork(int parameter)
    {
        qDebug()<<"receive the execute signal---------------------------------";
        qDebug()<<"     current thread ID:"<<QThread::currentThreadId();
       //循环一百万次
       for(int i = 0;i!=1000000;++i)
       {
        ++parameter;
       }
       //发送结束信号
       qDebug()<<"      finish the work and sent the resultReady signal\n";
       emit resultReady(parameter);
    }

//线程完成工作时发送的信号
signals:
    void resultReady(const int result);
};

#endif // WORKER_H

 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

然后定义一个Controller类，这个类中定义了一个QThread对象，用于处理worker对象的事件循环工作。

Controller.h

#ifndef CONTROLLER_H
#define CONTROLLER_H
#include <QObject>
#include<QThread>
#include<QDebug>
//controller用于启动线程和处理线程执行结果
class Controller : public QObject
{
    Q_OBJECT
    QThread workerThread;
public:
    Controller(QObject *parent= nullptr);
    ~Controller();

public slots:
    //处理线程执行的结果
    void handleResults(const int rslt)
    {
        qDebug()<<"receive the resultReady signal---------------------------------";
        qDebug()<<"     current thread ID:"<<QThread::currentThreadId()<<'\n';
        qDebug()<<"     the last result is:"<<rslt;
    }
signals:
    //发送信号触发线程
    void operate(const int);

};

#endif // CONTROLLER_H

 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

Controller类的cpp文件，其构造函数中创建worker对象，并且将其事件循环全部交给workerThread对象来处理，最后启动该线程，然后触发其事件处理函数。

controller.cpp

#include "controller.h"
#include <worker.h>
Controller::Controller(QObject *parent) : QObject(parent)
{
    Worker *worker = new Worker;
    //调用moveToThread将该任务交给workThread
    worker->moveToThread(&workerThread);
    //operate信号发射后启动线程工作
    connect(this, SIGNAL(operate(const int)), worker, SLOT(doWork(int)));
    //该线程结束时销毁
    connect(&workerThread, &QThread::finished, worker, &QObject::deleteLater);
    //线程结束后发送信号，对结果进行处理
    connect(worker, SIGNAL(resultReady(int)), this, SLOT(handleResults(int)));
    //启动线程
    workerThread.start();
    //发射信号，开始执行
    qDebug()<<"emit the signal to execute!---------------------------------";
    qDebug()<<"     current thread ID:"<<QThread::currentThreadId()<<'\n';
    emit operate(0);
}
//析构函数中调用quit()函数结束线程
Controller::~Controller()
{
    workerThread.quit();
    workerThread.wait();
}

 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

接下来就是主函数，主函数中我们新建一个Controller对象，开始执行：

main.cpp

#include <QCoreApplication>
#include "controller.h"
#include<QDebug>
#include<QThread>
int main(int argc, char *argv[])
{
    qDebug()<<"I am main Thread, my ID:"<<QThread::currentThreadId()<<"\n";
    QCoreApplication a(argc, argv);

    Controller c;
    return a.exec();
}
 
 1
2
3
4
5
6
7
8
9
10
11
12

运行结果及说明

这里写图片描述

运行结果截图 1
main函数中打印当前线程编号，即主线程的线程编号是0X7a4, 在Controller的构造函数中继续打印当前线程编号，也是主线程编号，之后把work类的工作交给子线程后，给子线程发送信号，子线程收到了信号开始执行，其线程号为0X1218，执行结束后发送信号给Controller处理结果。

方法二. 继承QThread的方法

方法描述

自定义一个继承QThread的类MyThread,重载MyThread中的run()函数，在run()函数中写入需要执行的工作.
调用start()函数来启动线程。

继承QThread的例子

首先写MyThread类，该类继承于QThread,该类中自定义了信号槽和重写了run函数。头文件如下：

MyThread.h

#ifndef MYTHREAD_H
#define MYTHREAD_H
#include<QThread>
#include<QDebug>
class MyThread : public QThread
{
    Q_OBJECT
public:
    MyThread(QObject* parent = nullptr);
    //自定义发送的信号
signals:
    void myThreadSignal(const int);
    //自定义槽
public slots:
    void myThreadSlot(const int);
protected:
    void run() override;
};

#endif // MYTHREAD_H

 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

MyThread.cpp

#include "mythread.h"

MyThread::MyThread(QObject *parent)
{

}

void MyThread::run()
{
    qDebug()<<"myThread run() start to execute";
    qDebug()<<"     current thread ID:"<<QThread::currentThreadId()<<'\n';
    //循环一百万次
    int count = 0;
    for(int i = 0;i!=1000000;++i)
    {
     ++count;
    }
    //发送结束信号
    emit myThreadSignal(count);
    exec();
}

void MyThread::myThreadSlot(const int val)
{
    qDebug()<<"myThreadSlot() start to execute";
    qDebug()<<"     current thread ID:"<<QThread::currentThreadId()<<'\n';
    //循环一百万次
    int count = 888;
    for(int i = 0;i!=1000000;++i)
    {
     ++count;
    }
}

 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

在Controller类中实现这MyThread的调用

Controller.h

#include "mythread.h"

MyThread::MyThread(QObject *parent)
{

}

void MyThread::run()
{
    qDebug()<<"myThread run() start to execute";
    qDebug()<<"     current thread ID:"<<QThread::currentThreadId()<<'\n';
    //循环一百万次
    int count = 0;
    for(int i = 0;i!=1000000;++i)
    {
     ++count;
    }
    //发送结束信号
    emit myThreadSignal(count);
    exec();
}

void MyThread::myThreadSlot(const int val)
{
    qDebug()<<"myThreadSlot() start to execute";
    qDebug()<<"     current thread ID:"<<QThread::currentThreadId()<<'\n';
    //循环一百万次
    int count = 888;
    for(int i = 0;i!=1000000;++i)
    {
     ++count;
    }
}

 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

Controller.cpp

#include "controller.h"
#include <mythread.h>
Controller::Controller(QObject *parent) : QObject(parent)
{
    myThrd = new MyThread;
    connect(myThrd,&MyThread::myThreadSignal,this,&Controller::handleResults);
    //该线程结束时销毁
    connect(myThrd, &QThread::finished, this, &QObject::deleteLater);
    connect(this,&Controller::operate,myThrd,&MyThread::myThreadSlot);
    //启动该线程
    myThrd->start();
    QThread::sleep(5);
    emit operate(999);
}

Controller::~Controller()
{
    myThrd->quit();
    myThrd->wait();
}
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

main函数的内容和上例中相同，因此就不贴了。

运行结果和说明：

这里写图片描述

运行结果截图2

通过自定义一个继承QThread的类，实例化该类的对象，重载run()函数为需要做的工作。然后在需要的地方调用start函数来执行run函数中的任务。然而有趣的是，myThread.start()之后我又从主函数触发了一个信号，对应于子线程的槽，子线程的槽函数中打印当前执行的线程的编号，可以看到，执行子线程的槽函数的线程编号却是主线程的编号。

两种方法的比较

两种方法来执行线程都可以，随便你的喜欢。不过看起来第二种更加简单，容易让人理解。不过我们的兴趣在于这两种使用方法到底有什么区别？其最大的区别在于：

moveToThread方法，是把我们需要的工作全部封装在一个类中，将每个任务定义为一个的槽函数，再建立触发这些槽的信号，然后把信号和槽连接起来，最后将这个类调用moveToThread方法交给一个QThread对象，再调用QThread的start()函数使其全权处理事件循环。于是，任何时候我们需要让线程执行某个任务，只需要发出对应的信号就可以。其优点是我们可以在一个worker类中定义很多个需要做的工作，然后发出触发的信号线程就可以执行。相比于子类化的QThread只能执行run()函数中的任务，moveToThread的方法中一个线程可以做很多不同的工作（只要发出任务的对应的信号即可）。
子类化QThread的方法，就是重写了QThread中的run()函数，在run()函数中定义了需要的工作。这样的结果是，我们自定义的子线程调用start()函数后，便开始执行run()函数。如果在自定义的线程类中定义相关槽函数，那么这些槽函数不会由子类化的QThread自身事件循环所执行，而是由该子线程的拥有者所在线程（一般都是主线程）来执行。如果你不明白的话，请看，第二个例子中，子类化的线程的槽函数中输出当前线程的ID，而这个ID居然是主线程的ID！！事实的确是如此，子类化的QThread只能执行run()函数中的任务直到run()函数退出，而它的槽函数根本不会被自己的线程执行。

PS:
以上代码是Qt5.7开发环境，采用的是VS2015的64位编译器。代码可以直接复制粘贴运行