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

已于 2022-12-21 14:56:40 修改
阅读量1.1k 收藏 4
点赞数
分类专栏： QT 文章标签： qt 开发语言 c++
于 2022-11-08 11:35:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Mydolen/article/details/127666900
版权

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

Mydolen
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Qt子线程如何更新UI，完整的代码示例
琅嬛福地
09-11 2万+
Qt涉及到大量的数据更新，图像处理，视频编解码时，在主线程直接进行会让主线程阻塞，程序直接卡死，直达阻塞的部分完成，界面才更新，大家会想到用多线程来解决这类问题，但是Qt的子线程中又无法更新UI, 这是很麻烦的事，不像MFC子线程可以直接操作UI，其实Qt在子线程也可以更新UI线程。 例如下面的界面，信息在线程产生，主线程如何获得呢? ...
Qt多线程基础（三）子线程与主线程通信
热门推荐
Ctrlturtle的博客
11-04 1万+
一、澄清概念 1.Qt主线程 Qt的主线程是唯一运行创建QApplication对象并调用exec()的线程，主要用于界面显示，因此又被称为GUI线程。 2.Qt子线程 Qt的子线程用于一些耗时操作，因此又被称为工作线程。 子线程不能用于直接刷新界面（QWidget不可重入，QObject可重入）。 若子线程企图修改界面控件，可通过线程间通信的方式：Qt的信号槽机制是跨线程的，因此可以
Qt多线程中调用QTimer
hscoder的博客
05-25 1万+
单独使用QThread多线程和QTimer定时器很简单，今天要利用子线程读取视频并显示，在QThread的派生类中使用QTimer，在触发QTimer的timeout()信号之后总是无法触发其槽函数，费了很大力气，终于解决，希望能对遇到同样问题的一定的帮助。 首先，创建一个简单的工程，基类选择QDialog。 其次，添加一个QThread的子类，其头文件如下：#ifndef MYTHREAD_H
Qt 线程 QThread类详解
最新发布
weixin_50873490的博客
07-08 1218
上述提到的两种使用QThread的方式有以下几点主要区别: (第一种重写 第二种movetoThread)线程的创建方式***线程与工作对象的关系在第一种方式中,线程和工作逻辑是耦合在一起的,因为工作逻辑直接在QThread的子类中实现。在第二种方式中,线程和工作对象是解耦的,工作逻辑被封装在独立的Worker对象中。***信号槽的执行位置:move版本槽函数无论是线程的信号触发还是自定义信号触发，槽函数都在新线程里运行。重写版本信号槽是在主线程执行。线程安全性。
Qt学习：子线程QThread的使用
壁立千仞无欲则刚的博客
05-30 6499
在开发过程中，碰到一些耗时的操作，如果直接在主线程里处理，UI将会出现假死的现象，甚至程序会崩溃，所以这类操作最好放在子线程当中。这里有2个对象，一个是QThread，即子线程；另一个是继承于QObject的一个类，这个是要在子线程里运行的代码片段。因为这个QObject非常基础，所以几乎所有继承于其他组件的自定义类，都间接地继承于QObject，都可以放入QThread中运行。1、首先定义一个要...
Qt中线程的使用
WSTONECH的博客
07-03 1325
Qt中线程，线程池等的使用；QTimer在线程中的应用等
QT多线程的使用
qq_48597462的博客
05-15 1261
QT中的线程用于实现多任务并发执行，提高程序的执行效率和响应速度。在QT中，线程是进行运算调度的最小单位，它们包含在进程之中并作为进程中的实际运作单位。使用线程的主要目的是让程序能够同时执行多个任务。提高性能和响应速度：通过将耗时的操作放在单独的线程中执行，可以避免UI冻结，提高应用程序的响应速度。实现多任务处理：一个进程中可以并发运行多个线程，每条线程并行执行不同的任务，有效地利用了计算机多核处理器的能力。简化复杂操作。
【Qt线程-3】使用事件循环，信号，stop变量，sleep阻塞，QWaitCondition+QMutex条件变量，退出子线程工作
大橘子的博客
10-08 4553
主线程终结子线程工作时，采用的几种方式对比。各有利弊，分别适用不同的场景。
Qt中多线程的使用（二）
yao5hed的专栏
07-19 913
线程池 当线程的任务量比较大时，频繁创建和销毁线程会有很大的内存开销，此时使用QThread的方法就不合适，应该使用线程池QThreadPool。QThread适用于常驻内存的任务，QThreadPool适用于不常驻内存，任务量比较大的情况。 QRunnable 是一个非常轻量的抽象类，它的主体是纯虚函数 QRunnable::run()，我们需要继承它并实现这个函数。使用时需要将其子类的实例...
Qt中的多线程
玉心的博客
08-03 4853
1 线程的基本概念 通俗地来说，线程是进程中实际执行代码的最小单元，它由操作系统安排调度（何时启动、何时运行和暂停以及何时消亡）。在一个进程中，线程是实际干活的单位。因此一个进程至少得有一个线程，我们把这个线程称之为“主线程”。 在Qt中，如果管理线程的线程对象被销毁时该线程仍在运行，则程序将会报告异常。所以在Qt程序中，如果退出主线程时仍有子线程在运行，程序将会报告异常。除非管理这些子线程的对象在程序退出时不会被销毁。例如： // 正常退出的程序 int main(int argc, char *argv
qt中子线程的回调函数
12-02
在QT中，可以通过在子线程中使用回调函数来实现多态性和降低线程的耦合性。具体实现方法如下： 1.定义回调函数，例如： ```cpp typedef std::function(const QString&)> CallbackFunc; ``` 2.在子线程中使用回调...
python多线程编程：浅谈PyQt5中异步刷新UI和Python多线程总结
python多线程基础教程进阶教程
02-10 2064
今天小编就为大家分享一篇浅谈PyQt5中异步刷新UI和Python多线程总结，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧 目前任务需要做一个界面程序，PyQt是非常方便的选择，QT丰富的控件以及python方便的编程。近期遇到界面中执行一些后台任务时界面卡死的情况，解决了在这里记录下。 PyQt PyQt简介 PyQt是Qt的python接口，PyQt的文档较少，但接口和函数可...
Qt 多线程
weixin_46870692的博客
10-24 365
Qt 多线程的运用实例
《QT从基础到进阶·十九》QThread多线程使用
cs1395293598的博客
11-10 460
不同线程共用同一个锁可以防止同时打印数据，比如两个线程同时打印0-100，如果给两个线程不加锁，或者各自定义一个锁，那两个线程都会一起打印0-100，如果两个线程用同一个锁，那么在第一个线程打印0的时候，第二个线程阻塞，当第一个线程释放锁的时候，第一个或第二个线程谁先抢到锁谁继续打印。thead.star()后并不会执行线程的内容，仅仅是启动了线程，线程的内容是doWork函数里的内容，当发送信号emit operate后才是真正执行线程的内容doWork函数。//开启子线程执行循环。
Qt项目第四弹-多线程调用
weixin_42146176的博客
02-02 647
多线程使用，项目中一定会用到
QT多线程QThread::run()与QObject::moveToThread()标准用法
野生猿-群号1025127672
04-07 4910
目录 1、使用QThread::run() 2、使用QObject::moveToThread 3、常见的错误编程方法 QT实现多线程有两种方法： 1、继承QThread类，并重写run()函数； 2、写一个对象worker，声明或new一个QThread变量thread，然后把这个对象移动到子线程中：worker.moveToThread(&thread);...
Qt -- 两种子线程
Furrain的博客
10-27 330
详细请见添加链接描述 这里继承QObject的子线程为什么要用信号槽机制来使用呢，一开始我不是很理解，后来试了一下，如果直接调用那个函数的话，因为子线程本来就是要处理耗时操作的，直接调用会进入到那个函数，就执行了耗时操作，执行完才会进入下一行代码，子线程就没有意义。用信号槽的话，我们就直接发一个信号就完事了，直接进入下一行代码，达到了子线程的目的。（耗时操作应该是进入到时间循环后再执行的，main...
QT中的线程
weixin_49606782的博客
09-23 2704
主线程(又称 GUI线程),负责监控窗口上的任何事件,一旦发现事件,立马处理.GUI线程只负责 UI刷新.但是有时候,任务很耗时,GUI进程会卡住,UI无响应这个时候创建一个新的子线程,负责处理 耗时的任务,注意：非GUI线程禁止访问 界面上任何元素.
qt中创建子线程最简单的方法（不用新建QThread和QObject的子类）
老薛的专栏
01-12 1007
在主线程中创建一个自定义信号，并用connect来关联QObject子类中的槽函数。将QObject子类对象指针moveToThread到QThread子类的对象指针。回归正题，最简单的创建线程的方法，不需要创建新类，不需要创建新文件。先啰嗦几句，写一下传统的两种方法，最简单创建线程的方式在文章末尾。在主线程中创建QThread子类的对象指针。在主线程中创建QObject子类对象指针。在主线程中创建QThread的对象指针。调用对象指针的start方法。创建QObject的子类，创建QThread的子类。
QT中子线程如何使用QMessageBox
07-08
在Qt中，主线程通常用于处理用户界面和事件循环，而子线程用于执行耗时的任务，以避免阻塞主线程。由于QMessageBox是一个模态对话框，它需要在主线程中使用。 如果你想在子线程中显示一个消息框，你可以使用Qt的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值