Chemmy's Blog

chengming0916@gmail.com

0%

发表于 Valine：

Qt线程之QRunnable的使用详解_qt qrunnable-CSDN博客

Excerpt

文章浏览阅读2.4k次，点赞4次，收藏19次。概述说到线程通常会想到QThread，但其实Qt中创建线程的方式有多种，这里主要介绍其中一种QRunnable，QRunnable和QThread用法有些不同，并且使用场景也有区别。接下来就来看看QRunnable的用法、使用场景以及注意事项。用法要使用QRunnable创建线程，步骤如下：继承QRunnable。和QThread使用一样， 首先需要将你的线程类继承于QRunnable。重写run函数。还是和QThread一样，需要重写run函数，run是一个纯虚函数，必须重写。使用_qt qrunnable

概述

说到线程通常会想到QThread，但其实Qt中创建线程的方式有多种，这里主要介绍其中一种QRunnable，QRunnable和QThread用法有些不同，并且使用场景也有区别。接下来就来看看QRunnable的用法、使用场景以及注意事项。

用法

要使用QRunnable创建线程，步骤如下：

  • 继承QRunnable。和QThread使用一样， 首先需要将你的线程类继承于QRunnable。
  • 重写run函数。还是和QThread一样，需要重写run函数，run是一个纯虚函数，必须重写。
  • 使用QThreadPool启动线程

和QThread的区别

  • 与外界通信方式不同。由于QThread是继承于QObject的，但QRunnable不是，所以在QThread线程中，可以直接将线程中执行的结果通过信号的方式发到主程序，而QRunnable线程不能用信号槽，只能通过别的方式，等下会介绍。
  • 启动线程方式不同。QThread线程可以直接调用start()函数启动，而QRunnable线程需要借助QThreadPool进行启动。
  • 资源管理不同。QThread线程对象需要手动去管理删除和释放，而QRunnable则会在QThreadPool调用完成后自动释放。

注释

  • 作为Qt类中少有的基类， QRunnable提供了简洁有效的可运行对象的创建.  用QRunnable来创建独立的运行对象来运行 不涉及界面元素的数据处理过程 非常合适.
  • 优点: 创建过程简洁， 使用方便， 配合着自身的autoDelete特性， 有点“招之即来， 挥之即去”的感觉.
  • 缺点: 无法实时提供自身的运行状态.

示例

首先我们新建一个类，继承于QRunnable

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


#include <QRunnable>

#include <QWidget>

class CusRunnable : public QRunnable

{

public:

explicit CusRunnable();

~CusRunnable();

void run();

};

#endif


  • 源文件
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
#include "cusrunnable.h"

#include <QDebug>

#include <QThread>

CusRunnable::CusRunnable()

{

}

CusRunnable::~CusRunnable()

{

qDebug() << __FUNCTION__;

}

void CusRunnable::run()

{

qDebug() << __FUNCTION__ << QThread::currentThreadId();

QThread::msleep(1000);

}
  • 然后在主界面中调用该线程。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include <QWidget>

#include "cusrunnable.h"

class Widget : public QWidget

{

Q_OBJECT

public:

Widget(QWidget *parent = 0);

~Widget();

private:

CusRunnable * m_pRunnable = nullptr;

};

#endif
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
#include "widget.h"

#include <QThreadPool>

#include <QDebug>

Widget::Widget(QWidget *parent)

: QWidget(parent)

{

m_pRunnable = new CusRunnable(this);

qDebug() << __FUNCTION__ << QThread::currentThreadId();

QThreadPool::globalInstance()->start(m_pRunnable);

}

Widget::~Widget()

{

qDebug() << __FUNCTION__ ;

}

输出结果：

1
2
3
4
5
Widget::Widget 0x199c

CusRunnable::run 0x1bcc

CusRunnable::~CusRunnable

我们可以看到这里打印的线程ID是不同的，说明是在不同线程中执行，而线程执行完后就自动进入到析构函数中， 不需要手动释放。

启动线程方式

上面我们说到要启动QRunnable线程，需要QThreadPool配合使用，而调用方式有两种：全局线程池和非全局线程池。

全局线程池

上面示例中启动方式就是用的全局线程池来启动QRunnable，使用很简单：

1
QThreadPool::globalInstance()->start(m_pRunnable);
  • 非全局线程池

除此之外，还可以使用非全局线程池的方式来实现，该方式可以控制线程最大数量， 以及其他设置，比较灵活，具体参照帮助文档。

1
2
3
4
5
QThreadPool threadpool;

threadpool.setMaxThreadCount(1);

threadpool.start(m_pRunnable);
  • 与外界通信

前面我们提到，因为QRunnable没有继承于QObject，所以没法使用信号槽与外界通信，那么，如果要在QRunnable线程中和外界通信怎么办呢，通常有两种做法：

  • 使用多继承。让我们的自定义线程类同时继承于QRunnable和QObject，这样就可以使用信号和槽，但是多线程使用比较麻烦，特别是继承于自定义的类时，容易出现接口混乱，所以在项目中尽量少用多继承。
  • 使用QMetaObject::invokeMethod。

QMetaObject::invokeMethod

函数定义如下：

1
[static] bool QMetaObject::invokeMethod(QObject *obj, const char *member, Qt::ConnectionType type, QGenericReturnArgument ret, QGenericArgument val0 = QGenericArgument( Q_NULLPTR ), QGenericArgument val1 = QGenericArgument(), QGenericArgument val2 = QGenericArgument(), QGenericArgument val3 = QGenericArgument(), QGenericArgument val4 = QGenericArgument(), QGenericArgument val5 = QGenericArgument(), QGenericArgument val6 = QGenericArgument(), QGenericArgument val7 = QGenericArgument(), QGenericArgument val8 = QGenericArgument(), QGenericArgument val9 = QGenericArgument())
  • 该函数就是尝试调用obj的member函数，可以是信号、槽或者Q_INVOKABLE声明的函数（能够被Qt元对象系统唤起），如果调用成功，返回true，失败返回false，具体使用方法就不在这里介绍。

QMetaObject::invokeMethod可以是异步调用，也可以是同步调用。这取决与它的连接方式Qt::ConnectionType type。如果type为Qt::DirectConnection，则为同步调用，若为Qt::QueuedConnection，则为异步调用。

来看一下，在上面的示例中，我们如何通过QMetaObject::invokeMethod让QRunnable线程与外部主线程通信。

假如我们在主界面中定一个函数，用于更新界面内容：

1
Q_INVOKABLE void setText(QString msg);
  • 然后线程类需要修改一下：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class CusRunnable : public QRunnable

{

public:

explicit CusRunnable(QObject *obj);

~CusRunnable();

void run();

private:

QObject * m_pObj = nullptr;

};
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
CusRunnable::CusRunnable(QObject * obj):

m_pObj(obj)

{

}

CusRunnable::~CusRunnable()

{

qDebug() << __FUNCTION__;

}

void CusRunnable::run()

{

qDebug() << __FUNCTION__ << QThread::currentThreadId();

QMetaObject::invokeMethod(m_pObj,"setText",Q_ARG(QString,"this is AA!"));

QThread::msleep(1000);

}
  • 注意，这里的调用方式：
1
QMetaObject::invokeMethod(m_pObj,"setText",Q_ARG(QString,"this is AA!"));
  • 其中"setText"就是要调用的函数，传参方式Q_ARG(QString,"this is AA!")，表示传入一个QString类型，值为"this is AA!"

而在创建线程对象时，需要将主界面对象传入线程类

1
m_pRunnable = new CusRunnable(this);
  • 这样一来就可以在线程中和外界通信了。

遇到的问题

使用QThreadPool调用线程后，线程执行完会自动释放资源，但是我使用的时候遇到一个问题，未找到原因。就是在该线程对象都已经释放过后（已经进入到析构函数了），该对象还可以继续使用，还可以使用该对象调用线程类中的函数，也就是说，理论上该对象指针已经释放了，这时候变成了野指针，并且线程对象值不为空。

做了一个试验，在执行完线程后，再次使用线程对象指针调用线程类中的函数，结果还是可以用。
关键代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
m_pRunnable = new CusRunnable(this);

qDebug()<< __FUNCTION__ << QThread::currentThreadId();

QThreadPool::globalInstance()->start(m_pRunnable);

m_pBtn = new QPushButton(this);

m_pBtn->setText("click me");

connect(m_pBtn,&QPushButton::clicked,this,[=](){

qDebug() << __FUNCTION__ << m_pRunnable;

m_pRunnable->Func();

});
  • 这里每次点击按钮，就会调用一次线程类中的函数。输出如下：
1
2
3
4
5
6
7
8
9
10
11
Widget::Widget 0x3794

CusRunnable::run 0x39e0

Widget::setText "this is AA!"

CusRunnable::~CusRunnable

Widget::{ctor}::<lambda_e0d3aa46abd43a56277208964007553d>::operator () 0x1045348

Widget::{ctor}::<lambda_e0d3aa46abd43a56277208964007553d>::operator () 0x1045348

从上面可以看到，已经进入到了析构函数，但是依然可以使用该对象调用其中的函数，并且对象也不为空。

再次试验，在主界面析构函数中判断：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Widget::~Widget()

{

qDebug()<< __FUNCTION__ ;

if(m_pRunnable){

delete m_pRunnable;

m_pRunnable = nullptr;

}

}
  • 关闭程序的时候，会出现异常退出，也就是说，该指针确实释放了，不能再次delete，变成了一个野指针。

所以最终结论，QThreadPool在调用线程执行完后确实会释放资源，但是并不会将对象置空，这时候对象变成了一个野指针，如果还是用这个指针的话可能会出现隐患错误，所以最好不好这样调用。而在程序最终退出时，可以将该线程对象置空，但是不能再次delete，否则将会异常。