QT中子线程和多线程的使用记录

原创 已于 2022-12-21 14:56:40 修改 · 1.4k 阅读 · 5 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#qt #开发语言 #c++
于 2022-11-08 11:35:08 首次发布
本文详细介绍了在QT中实现多线程的几种方法，包括使用QObject结合moveToThread，继承QThread重写run函数，利用QThreadPool管理和调度线程，以及使用QtConcurrent进行并发编程。同时探讨了线程间通信的机制。

QT中子线程和多线程的使用记录档

子线程

在QT中将子类中的运算扔到子线程中有两种方法，一种是将子类继承于QObject，调用QObject::moveToThread()方法，从主线程中发送信号调用子类的槽函数；另一种是将子类继承于QThread，重写run()函数。

继承于QObject

子类定义

//.h
class MyChildQObjectThread : public QObject
{
    Q_OBJECT
public:
    MyChildQObjectThread();
    ~MyChildQObjectThread();
public slots:
    void slot_perform();
signals:
    void sig_begin_perform();
    void sig_finish_perform();
};
//.cpp
MyChildQObjectThread::MyChildQObjectThread()
{
    qDebug()<<"MyChildQObjectThread的构造函数所在线程："<<QThread::currentThreadId();
    connect(this,&MyChildQObjectThread::sig_begin_perform,this,&MyChildQObjectThread::slot_perform);
}

MyChildQObjectThread::~MyChildQObjectThread()
{
    qDebug()<<"MyChildQObjectThread的析构函数所在线程："<<QThread::currentThreadId();
}

void MyChildQObjectThread::slot_perform()
{
    qDebug()<<"MyChildQObjectThread的执行函数所在线程："<<QThread::currentThreadId();
    emit sig_finish_perform();
}

应用

//.h
	QThread WorkThread;
	MyChildThread *pMyChildThread;
//.cpp
	pMyChildQObjectThread = new MyChildQObjectThread();
	pMyChildQObjectThread->moveToThread(&WorkThread);
	connect(&WorkThread,&QThread::finished,pMyChildQObjectThread,&QObject::deleteLater);
	connect(pMyChildQObjectThread,&MyChildQObjectThread::sig_finish_perform,this,&MainWindow::slot_receive_perform);
	WorkThread.start();
	emit pMyChildQObjectThread->sig_begin_perform();

运行结果

	MainWindow 所在线程： 0x658
	MyChildQObjectThread的构造函数所在线程： 0x658
	MyChildQObjectThread的执行函数所在线程： 0x7204
	MyChildQObjectThread的析构函数所在线程： 0x7204

总结

  1. 当子类继承于QObject时，需要定义一个QThread线程用来调用QObject::moveToThread()方法。
  2. 子类的构造函数是在主线程中执行，槽函数及子类析构函数均在子线程中执行。
  3. 子类的析构，需要通过手动释放定义的QThread，通过QThread::finished()信号来调用QObject::deleteLater()，以此进入析构函数；不然定义的QThread不会自动结束线程。

继承于QThread

//.h
class MyChildThread : public QThread
{
    Q_OBJECT
public:
    MyChildThread();
    ~MyChildThread();
protected:
    void run() override;
signals:
};
//.cpp
MyChildThread::MyChildThread()
{
    qDebug()<<"MyChildThread的构造函数所在线程："<<QThread::currentThreadId();
}

MyChildThread::~MyChildThread()
{
    qDebug()<<"MyChildThread的析构函数所在线程："<<QThread::currentThreadId();
}

void MyChildThread::run()
{
    qDebug()<<"MyChildThread的执行函数所在线程："<<QThread::currentThreadId();
}

应用

	pMyChildThread = new MyChildThread();
	connect(pMyChildThread,&QThread::finished,pMyChildThread,&QObject::deleteLater);
	pMyChildThread->start();

运行结果

	MainWindow 所在线程： 0x6968
	MyChildThread的构造函数所在线程： 0x6968
	MyChildThread的执行函数所在线程： 0x1694
	MyChildThread的析构函数所在线程： 0x6968

总结

  1. 当子类继承于QThread时，需要重写run()函数来执行想要在子线程中执行的操作。
  2. 子类的构造函数和析构函数均在主线程中执行，run()函数在子线程中执行。
  3. run()函数执行完毕之后线程即销毁，在finished()信号与deleteLater()连接后执行析构函数。

线程池

以下是QT帮助文档中对线程池的描述

QThreadPool管理和回收单独的QThread对象，以帮助减少使用线程的程序中的线程创建成本。每个Qt应用程序都有一个全局QThreadPool对象，可以通过调用globalInstance()来访问它。
要使用一个QThreadPool线程，子类QRunnable并实现run()虚函数。然后创建该类的一个对象并将其传递给QThreadPool::start()。

从上述描述中，我们可以得知，在程序运行过程中对线程的创建和销毁是需要耗费资源的，因此当在需要频繁创建&销毁子线程的场景中，使用QThreadPool是个不错的选择。

子类定义

//.h
struct MyStruct{
    int x;
    QString str;
};

class MyThreadPool : public QObject, public QRunnable
{
    Q_OBJECT
public:
    MyThreadPool(MyStruct temp);
    ~MyThreadPool();
protected:
    void run() override;
private:
    MyStruct 		m_struct;
    QElapsedTimer   test_timer;
signals:
    void sig_output(MyStruct result);
};

//.cpp
MyThreadPool::MyThreadPool(MyStruct temp) : m_struct(temp)
{
    qDebug()<<"MyThreadPool的构造函数所在线程："<<QThread::currentThreadId();
}

MyThreadPool::~MyThreadPool()
{
    qDebug()<<"MyThreadPool的析构函数所在线程："<<QThread::currentThreadId();
}

void MyThreadPool::run()
{
    test_timer.restart();
    while(test_timer.elapsed() < 100)
        ;
    int id = (int)(QThread::currentThreadId());
    m_struct.str.append(tr("第%1次线程ID:0x").arg(m_struct.x));
    m_struct.str.append(QString::number(id,16));
    emit sig_output(m_struct);
}

应用

{
	p_my_threadpool = new MyThreadPool(mystruct);
	connect(p_my_threadpool,&MyThreadPool::sig_output,this,&MainWindow::slot_receive_result);
	p_my_threadpool->setAutoDelete(m_auto_delete_runnable);
	QThreadPool::globalInstance()->start(p_my_threadpool);
}
void MainWindow::slot_receive_result(MyStruct temp)
{
    ui->textEdit->append(QString("接收到处理结果：%1\n").arg(temp.x).append(temp.str));
    if(temp.x == timer_max_count)
    {
        ui->textEdit->append(str);
    }
}

运行结果

	MainWindow 所在线程： 0x2c3c
	"MyThreadPool第1次的构造函数所在线程：" 0x2c3c
	"MyThreadPool第2次的构造函数所在线程：" 0x2c3c
	"MyThreadPool第3次的构造函数所在线程：" 0x2c3c
	"MyThreadPool第4次的构造函数所在线程：" 0x2c3c
	"MyThreadPool第5次的构造函数所在线程：" 0x2c3c
	"MyThreadPool第6次的构造函数所在线程：" 0x2c3c
	"MyThreadPool第7次的构造函数所在线程：" 0x2c3c
	"MyThreadPool第8次的构造函数所在线程：" 0x2c3c
	"MyThreadPool第9次的构造函数所在线程：" 0x2c3c
	"MyThreadPool第1次的析构函数所在线程：" 0x6fe0
	"MyThreadPool第10次的构造函数所在线程：" 0x2c3c
	"MyThreadPool第2次的析构函数所在线程：" 0x4a3c
	"MyThreadPool第3次的析构函数所在线程：" 0x1fd8
	"MyThreadPool第4次的析构函数所在线程：" 0x59d4
	"MyThreadPool第5次的析构函数所在线程：" 0x660c
	"MyThreadPool第6次的析构函数所在线程：" 0x54e0
	"MyThreadPool第7次的析构函数所在线程：" 0x6b10
	"MyThreadPool第8次的析构函数所在线程：" 0x56bc
	"MyThreadPool第9次的析构函数所在线程：" 0x445c
	"MyThreadPool第10次的析构函数所在线程：" 0x6fe0
	
	定时器1次结束计时
	定时器2次结束计时
	定时器3次结束计时
	定时器4次结束计时
	定时器5次结束计时
	定时器6次结束计时
	定时器7次结束计时
	定时器8次结束计时
	定时器9次结束计时
	定时器10次结束计时
	接收到处理结果：1
	第1次线程ID:0x6fe0
	接收到处理结果：2
	第2次线程ID:0x4a3c
	接收到处理结果：3
	第3次线程ID:0x1fd8
	接收到处理结果：4
	第4次线程ID:0x59d4
	接收到处理结果：5
	第5次线程ID:0x660c
	接收到处理结果：6
	第6次线程ID:0x54e0
	接收到处理结果：7
	第7次线程ID:0x6b10
	接收到处理结果：8
	第8次线程ID:0x56bc
	接收到处理结果：9
	第9次线程ID:0x445c
	接收到处理结果：10
	第10次线程ID:0x6fe0

总结

  1. 线程池的任务类需要重写run()函数来执行想要扔到子线程的耗时操作。
  2. 线程池的任务构造函数在主线程中执行，run()函数和析构函数均在子线程中执行。
  3. 默认情况下，在最后一个线程退出run()函数后，QThreadPool::autoDelete会删除任务类；
  4. 在多次重复调用相同任务类的场景下，启用autoDelete会创造一个竞态条件，因此推荐用QRunnable::setAutoDelete()禁用自动删除任务类。
  5. 线程池的子线程并不是在调用QThreadPool::globalInstance()->start()后立即执行，而是将任务类扔到一个任务队列中，按队列顺序执行；可以更改start()的第二个参数priority来控制该任务类的执行顺序。
  6. 由上述总结可以得出，线程池的结果输出顺序和任务类启用顺序不一致，因此需要注意在要求顺序输出的场景下进行额外操作。

并发线程类

2022.12.21日更新

Qt Concurrent类可以将一个函数扔到子线程中去执行，根据Qt文档的说明，它封装了高级API，避免使用互斥锁、读写锁、信号量这些低级线程用语。

我的个人使用示例如下：

  1. 在pro文件中包含
QT += concurrent
  1. 在相应头文件中包含
#include <QtConcurrent>
  1. 多数情况下，我们想在子线程中运行的函数应该是非静态的成员函数（就我个人情况而言），以MainWindow内函数为例：
void MainWindow::example_function(int input_A, int input_B)
{}
void MainWindow::run_Concurrent()
{
	int input_x, input_y;
	input_x = 1;
	input_y = 2;
#if (QT_VERSION >= QT_VERSION_CHECK(6,0,0))
	QFuture<void> result = QtConcurrent::run(&MainWindow::example_function,this,input_x,input_y);
#else
	QFuture<void> result = QtConcurrent::run(this,&MainWindow::example_function,input_x,input_y);
#endif 
	result.waitForFinished();
}

2022.12.21日更新完毕

线程间通信

不同线程中进行数据通信主要有两种方式：共享内存和信号槽。

共享内存

共享内存想起来后补充

信号槽

数据类型

信号槽默认可以传输QT自己的元数据类型，如QString、double、int等类型，若想要传输自定义结构体数据，则需要在定义一个结构体后调用Q_DECLARE_METATYPE来向QT注册自定义结构体，如下：

//.h
struct MyStruct{
    int x;
    QString str;
};
Q_DECLARE_METATYPE(MyStruct)

signals:
    void sig_output(MyStruct result);

//.cpp
connect(p_my_threadpool,&MyThreadPool::sig_output,this,&MainWindow::slot_receive_result);

connect的第五个参数

一般来说，我们在调用connect函数时只用了四个参数，即发送者，发送信号，接收者，接收槽函数，但是connect函数还存在了第五个参数：连接方式Qt::ConnectionType

连接类型使用场景
Qt::AutoConnection默认值，如果发送者和接收者在同一个线程，则执行Qt::DirectConnection，否则会执行Qt::QueuedConnection。
Qt::DirectConnection信号发出后，立即执行槽函数；槽函数在发送者线程执行。
Qt::QueuedConnection信号发出后，不会立即执行槽函数，而是等到接收者进入事件循环之后，槽函数才会被调用；槽函数在接收者线程执行。
Qt::BlockingQueuedConnection槽函数执行方式和Qt::QueuedConnection相同，不同之处在于该信号发出后，会阻塞发送者线程，直到槽函数执行完毕返回，因此若发送者和接收者在同一个线程中，将会造成死锁。此方式只能在多线程中运用。
Qt::UniqueConnection此连接方式在禁止多次连接相同信号和槽的时候启用，因为在信号和槽已经connect情况下再次连接时，connect将会失败。
Qt::SingleShotConnection此连接方式在只需要连接一次信号槽的时候启用，因为在信号发送一次后，connect将被断开，槽函数只会执行一次。

一般情况下，不需要设置第五个参数，QT会根据发送者和接收者所在的线程自行判断是用直接连接还是队列连接。

结语

以上是我在实际运用过程中的一点总结，以备后续查阅。
见识浅薄，以娱大家。
这是本项目的Github地址：ThreadPoolDemo
本项目编译环境：Qt 6.2.4 Community \ MSVC 2019

学习QT之子线程控制主界面UI控件
贝勒里恩的博客
03-28 8028
在子线程里控制主界面的UI控件有两种方法：第一种是在子线程中发送信号，然后在主线程中去更新；第二种方法是在子线程中创建同样的对象，然后把主界面中控件的指针赋给创建的对象。 第一种方法在此不做实例展示，在此通过一个简单的例子展示第二种方法： 下面是主界面的初始转态： 下面这个是继承自QThread类的子线程类 sonthread.h #ifndef SONTHREAD_H #define SONT...
QT 子线程两种创建方式
miao0967020148的专栏
08-27 3009
第一种：继承QThread #ifndef THREADFROMQTHREAD_H #define THREADFROMQTHREAD_H #include <QThread> #include <QObject> class ThreadFromQThread : public QThread { Q_OBJECT public: ThreadFromQThread(); protected: 　　void run(); }; #endif //
Qt学习：子线程QThread的使用
壁立千仞无欲则刚的博客
05-30 6764
在开发过程中，碰到一些耗时的操作，如果直接在主线程里处理，UI将会出现假死的现象，甚至程序会崩溃，所以这类操作最好放在子线程当中。这里有2个对象，一个是QThread，即子线程；另一个是继承于QObject的一个类，这个是要在子线程里运行的代码片段。因为这个QObject非常基础，所以几乎所有继承于其他组件的自定义类，都间接地继承于QObject，都可以放入QThread中运行。1、首先定义一个要...
QT中创建线程的几种方法(QThread的使用示例)
Guoiaoang 的记事本
07-30 1842
QT中创建线程的几种方法，QThread的使用：1.创建QThread子类、2.使用Thread::Create创建、3.调用QObject::moveToThread转移线程。及子线程资源的释放。
QT中的线程
weixin_49606782的博客
09-23 2937
主线程(又称 GUI线程),负责监控窗口上的任何事件,一旦发现事件,立马处理.GUI线程只负责 UI刷新.但是有时候,任务很耗时,GUI进程会卡住,UI无响应这个时候创建一个新的子线程,负责处理 耗时的任务,注意：非GUI线程禁止访问 界面上任何元素.
Qt 串口多线程
Rough Set
06-11 7691
本文是Qt串口QSerialPort使用的入门篇，从获取串口到初始化、开关收发等做了简单的介绍。关于参数初始化方面，若有兴趣，如常用的串口调试助手一样可以自己将参数设置部分添加到界面中，然后通过获取界面上的参数来初始化参数。下一篇中，将介绍QSerialPort串口与QThread线程结合使用的内容。.........
记录一下QT movetothread多线程槽函数无法触发
asdasfdgdhh的博客
11-02 6524
QT movetothread多线程槽函数无法触发 movetothread以后主线程子线程的ID相同
【QT开发日志】QT多线程编程：实现高效的多线程应用
最新发布
鸽芷咕的博客
07-31 9675
在当今的软件开发领域，用户对应用程序的性能和响应速度要求越来越高。尤其是在处理复杂任务、大量数据或进行网络通信时，单线程往往难以满足需求，容易出现界面卡顿、操作无响应等问题，严重影响用户体验。
【QT5】＜重点＞ QT多线程
致力于Linux的博客
06-16 2409
本篇记录学习QT多线程的知识，参考视频13.1QThread创建多线程程序_哔哩哔哩。若涉及版权问题，请联系作者删除！
QT实现多线程，以及子线程调用主线程方法与变量
胡乱学点东西
05-09 8676
实现思路：第一步需要将子线程声明为主线程的友元类，第二步是将主线程类对象的地址通过信号槽传递给子线程中创建的对象，使得子线程能访问主线程的数据的
Qt创建线程(使moveToThread方法创建子线程)
weixin_44954230的博客
09-22 1785
（4）这种创建线程的方式很灵活，如果子线程不够用，可以把多个任务函数移动到其中的一个线程中，（一个子线程中可以同时关联多个任务函数，关联的多个任务函数是按照线性的顺序执行的）还可以先在线程1中执行任务函数a，然后在线程2中执行任务函数a(也就是一个任务函数可以在多个不同的线程中执行)（1）要使用moveToThread方法必须继承与QObject类。QThread和moveToThread两种方法都可以使用信号和槽。（3）任务类里面的任务函数可以有多个。（2）创建任务对象时不能指定父对象。
Qt 多线程
weixin_46870692的博客
10-24 503
Qt 多线程的运用实例
Qt Creator创建子线程的方法
Simple-Beauty的博客
05-15 1817
mainwindow.cpp /* 主窗口（主线程）的构造函数 */ MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent), ui(new Ui::MainWindow) { ui->setupUi(this); //创建的次线程 thread = new mythread1(this); //连接次线程和画界面的主线程，次线程时间更新后，会发信号给主线程并调用 connect(t
QT实现线程操作
new9232的博客
12-26 1947
1、第一种方法 第一种方法是QT4.8之前的写法，需要重写一个类，继承于QThread类。 1.1、自己实现一个子线程类myThread，并继承于QThread类。 1.2、重写子线程类myThread中的虚函数run()。 1.3、在主线程Widget中定义子线程类对象。 1.4、在主线程Widget中连接信号槽，实现子线程于主线程之前通信。 1.5、主线程Widget中使用子线程的start()方法启动子线程。 项目结构 主线程代码 widget.h #ifndef WID
Qt多线程创建流程
qq_27178903的博客
01-28 1681
什么是主线程？ 主线程在Qt中就是创建工程默认的那个main函数。 主线程的作用？ 用于主界面控件的操作，因为子线程是不能直接去操作主线程的控件，需要通过带参数的信号槽去互传信息。 主线程中最好不要放入耗时的业务代码，这样系统会卡顿，要将他们放到子线程中。 什么是子线程？ 子线程就是在主线程中创建的通常用于执行耗时业务代码的子程序。通常子线程是在一个whilie(1) {...}死循环中的。 子线程的作用？ 执行...
Qt多线程基础（三）子线程与主线程通信
热门推荐
Ctrlturtle的博客
11-04 1万+
一、澄清概念 1.Qt主线程 Qt的主线程是唯一运行创建QApplication对象并调用exec()的线程，主要用于界面显示，因此又被称为GUI线程。 2.Qt子线程 Qt的子线程用于一些耗时操作，因此又被称为工作线程。 子线程不能用于直接刷新界面（QWidget不可重入，QObject可重入）。 若子线程企图修改界面控件，可通过线程间通信的方式：Qt的信号槽机制是跨线程的，因此可以
【QT】：线程之间的通信操作(主线程与子线程，子线程与子线程和主线程同时通信，附源码案例)
weixin_44322778的博客
04-02 6751
多线程之间的变量传递
Qt中常用子线程方式
xu2245749792的博客
03-20 754
Qt中常用子线程使用方式以及每种方式的使用适用场景
Qt：多线程--子线程间通讯
老邹的博客
01-17 6996
一、基于Qt多线程的实现： 使用qt实现多线程有两种方式： 第一种：继承QThread类： 子类化**QThread**类得到类A 重写run()函数(run函数为虚函数)，一般可以在run函数中给定一个while循环或者for循环 通过实例化得到A的对象a,通过 QThread::start() 函数来启动线程 例如： a.子类化QThread class A:public QThread { Q_OBJECT public: void run() override {
Qt 线程 QThread类详解
weixin_50873490的博客
07-08 5232
上述提到的两种使用QThread的方式有以下几点主要区别: (第一种重写 第二种movetoThread)线程的创建方式***线程与工作对象的关系在第一种方式中,线程和工作逻辑是耦合在一起的,因为工作逻辑直接在QThread的子类中实现。在第二种方式中,线程和工作对象是解耦的,工作逻辑被封装在独立的Worker对象中。***信号槽的执行位置:move版本槽函数无论是线程的信号触发还是自定义信号触发，槽函数都在新线程里运行。重写版本信号槽是在主线程执行。线程安全性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值