Qt中的多线程

news/2024/12/29 22:34:33/

Qt中有多种方法实现多线程：

  1. QThread
  2. QThreadPool和QPunnable（重用线程）
  3. Qt Concurrent
  4. WorkerScript（QML中的线程）

QThread 在上两篇文章中已经解释了，这里就不再赘述。 

QThreadPoo和QRunnable（实现的多线程）

QRunnable：

QRunnable 类是一个接口，用于表示需要执行的任务或代码段，由 run 函数的重新实现表示。

autoDelete（）返回是否自动删除
setAutoDelete（）设置自动删除（thue）

设置自动删除的话，在QThreadPool中会自动删除QRunnable

 使用的注意事项：

 启用自动删除时，使用相同的 QRunnable 多次调用 QThreadPoool::start（） 会产生争用条件，不建议这样做。

QRunnable和QThread的区别：

  

 QThreadPool（线程池）

顾名思义，是有很多线程的池子， 可以管理池子中的线程。

线程池的优点：

  1. 降低资源消耗。 通过重复利用已创建的线程降低线程创建和销毁造成的消耗。
  2. 提高响应速度。 当任务到达时，任务可以不需要等到线程创建就能立即执行。
  3. 提高线程的可管理性。 线程是稀缺资源，使用线程池可以进行统一的分配、调优和监控。
  4.   

常用函数： 

setMaxThreadCount()  

设置线程池中最大的线程数，默认：QThread：：idealThreadCount
setExpiryTimeout（int）将超时xx毫秒未使用的线程视为已过期并将退出，已在运行的线程没有影响。建议在创建线程池后立即设置。
setStackSize()       设置线程池工作线程的堆栈大小，当线程池创建新线程时使用， 默认值为 0
clear（）清除队列中未开启的可运行项
globalInstance（）返回一个全局QThreadPool实例
reserveThread（）保留一个线程（ 此函数将始终增加活动线程数）
releaseThread（）释放reserveThread（）保留的线程
start（QRunnable,int）开启一个线程,可以设置优先级
tryStart（）尝试开启一个线程
tryTake（）尝试从队列中删除指定的尚未启动的可运行对象（谨慎使用）
waitForDone(int)等待所有线程退出最多毫秒毫秒，并从线程池中删除所有线程。如果删除了所有线程返回true
activeThreadCount（）当前活跃的线程数

启动QRunnable线程的方法： 

  1. 使用QThreadPool::globalInstance()->start()启动   （全局）
  2. 创建一个QThreadPool 对象，然后通过该对象启动

Runnable类：

#ifndef RUNNABLE_H
#define RUNNABLE_H
#include<QThread>
#include<QDebug>
#include<QRunnable>class Runnable:public QRunnable
{
public:explicit Runnable()//构造函数{}~Runnable()//析构函数{}void run()//重写run函数{qDebug()<<"Runnable中的run函数";qDebug()<<"thread to run():"<<QThread::currentThreadId();}
};
#endif // RUNNABLE_H

1.使用QThreadPool::globalInstance()->start()启动   （全局）

Widget::Widget(QWidget *parent): QWidget(parent), ui(new Ui::Widget)
{ui->setupUi(this);qDebug()<<"主线程号："<<QThread::currentThread();Runnable *able=new Runnable;QThreadPool::globalInstance()->start(able);}

  

2.创建一个QThreadPool 对象，然后通过该对象启动

Widget::Widget(QWidget *parent): QWidget(parent), ui(new Ui::Widget)
{ui->setupUi(this);qDebug()<<"主线程号："<<QThread::currentThread();Runnable *able=new Runnable;//QThreadPool::globalInstance()->start(able);QThreadPool pool;pool.start(able);}

  

 

线程池函数的使用

    QThreadPool pool;qDebug()<<"本机的线程数"<<QThread::idealThreadCount();qDebug()<<"线程池中的线程数"<<pool.maxThreadCount();pool.setMaxThreadCount(10);//设置线程池中最大的线程数pool.setExpiryTimeout(40000);//如果线程40000毫秒，40秒未使用，使它过期Runnable *runnable=new Runnable;pool.reserveThread();//保留一个线程pool.start(runnable);//开启线程qDebug()<<"当前活跃线程数："<<pool.activeThreadCount();pool.releaseThread();//释放那个保留的线程qDebug()<<"当前活跃线程数："<<pool.activeThreadCount();

    

QRunnable释放内存问题：

QRunnable可以执行完释放内存：需要将autoDelete（）设置为true，默认为true。

#ifndef RUNNABLE_H
#define RUNNABLE_H
#include<QThread>
#include<QDebug>
#include<QRunnable>class Runnable:public QRunnable
{
public:explicit Runnable()//构造函数{}~Runnable()//析构函数{qDebug()<<__FUNCTION__;}void run()//重写run函数{qDebug()<<"thread to run():"<<QThread::currentThreadId();}
};
#endif // RUNNABLE_H
    QThreadPool pool;Runnable *runnable=new Runnable;pool.start(runnable);//开启线程

执行完后自动调用析构函数。

  

QRunnable的通信问题：

由于QRunnable是单独的一个类，并没有继承QObject，所以没有connect（）函数，所以无法于外界进行通信。

解决该问题的方法：

  • 使用QMetaObject::invokeMethod()
  • 使用多继承的方式，同时继承QRunnable和QObject，但这样的话会使接口混乱（尽量不要使用）

QMetaObject::invokeMethod（）的创建方法 ：

QMetaObject：：invokeMethod（QObject *obj， //使用的类const char *member， //调用函数名Qt：：ConnectionType type，//调用类型QGenericReturnArgument ret，//用来存储返回值的类型QGenericArgument val0 = QGenericArgument（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（））//最多有10个参数

*obj：需要把使用类传进去

member：函数的名称

type：调用类型：

  1. Qt::DirectConnnect 立即调用该成员函数
  2. Qt::QueuedConnection 一旦应用程序进入主事件循环，就会发送 QEvent 并调用成员。
  3. Qt::BlockQueuedConnection 当前线程将阻塞，直到事件被传递。使用此连接类型在同一线程中的对象之间进行通信将导致死锁。
  4. Qt::AutoConnection 如果 obj 与调用方位于同一线程中，则同步调用成员;否则，它将异步调用该成员。

val0-val9：最多可以有10个参数

传参的方式：使用宏传参

  1. Q_ARG(type，const Type&value)
  2. Q_RETURN_ARG(type, Type&value)
QString S="hellow";
QMetaObject::invokeMethod(obj,              "Text",Qt::DirectConnection,Q_ARG(QString,"pppp"),Q_RETURN_ARG(QString,S));

Runnable函数：

#ifndef RUNNABLE_H
#define RUNNABLE_H
#include "widget.h"
#include<QThread>
#include<QObject>
#include<QDebug>
#include<QRunnable>
#include<QMetaObject>class Runnable:public QRunnable
{
public:explicit Runnable(QObject *obj1):obj(obj1)//构造函数{}~Runnable()//析构函数{}void run()//重写run函数{  QString S="hellow";QMetaObject::invokeMethod(obj,"Text",Qt::DirectConnection,Q_ARG(QString,"pppp"),Q_RETURN_ARG(QString,S));qDebug()<<"thread to run():"<<QThread::currentThreadId();}QObject *obj=nullptr;//需要传的对象
};
#endif // RUNNABLE_H

主函数：

主类中创建函数开头需要添加：Q_INVOKABLE（这样才直到调用哪一个函数）

#include "widget.h"
#include "ui_widget.h"
#include"runnable.h"
#include<QThreadPool>
class Rnnable;
Widget::Widget(QWidget *parent): QWidget(parent), ui(new Ui::Widget)
{ui->setupUi(this);QThreadPool pool;Runnable *runnable=new Runnable(this);//传入调用的对象pool.start(runnable);//开启线程
}
Q_INVOKABLE void Widget::Text(QString a,QString b)//创建一个函数，名称要相同
{qDebug()<<a;qDebug()<<b;
}
Widget::~Widget()
{delete ui;
}

    

Qt Concurrent（并发）

QtConcurrent命名空间提供高级 API，可以在不使用互斥锁、读写锁、等待条件或信号量等低级线程原语的情况下编写多线程程序。

使用 QtConcurrent编写的程序会根据可用的处理器内核数量自动调整使用的线程数。这意味着编写的应用程序在部署到多核系统时将自动扩展。

如何使用Qt Concurrent:

1.pro文件中添加

QT +=concurrent

2. 添加头文件

#include<QtConcurrent>

 以下是如何执行QtConcurrent的使用方法：

使用QtConcurrent::run（）函数执行内容

 函数模型：

//T为模板类型QFuture<T> QtConCurrent::run(Function)//执行一个函数QFuture<T> QtConCurrent::run(threadpool，Function)//线程池中，取出线程执行function函数

执行一个函数：

void text()
{qDebug()<<"ok";
}
void text1(int a)
{qDebug()<<a;
}
void text2(QString s1,QString s2)
{qDebug()<<s1+s2;
}
int main(int argc, char *argv[])
{QApplication a(argc, argv);QFuture<void> fu=QtConcurrent::run(text);QFuture<void> fu1=QtConcurrent::run(text1,10);QFuture<void> fu2=QtConcurrent::run(text2,QString("aa"),QString("bb")");fu.waitForFinished();//等待完成fu1.waitForFinished();//等待完成fu2.waitForFinished();//等待完成return a.exec();
}

   

通过线程池中的进程执行函数

void text1(int a)
{qDebug()<<a;
}int main(int argc, char *argv[])
{QApplication a(argc, argv);QThreadPool pool;QFuture<void> fu=QtConcurrent::run(&pool,text1,10);fu.waitForFinished();//等待完成return a.exec();
}

  

3.调用常量成员函数：

run（）函数可以接收成员函数的指针，第一个参数必须是常量引用或指向类实例的指针。

QByteArray bytearray = "hello world";
QFuture<QList<QByteArray> > future = QtConcurrent::run(bytearray, &QByteArray::split, ',');
QList<QByteArray> result = future.result();

4.调用非常量成员函数：

QImage image = ...;
QFuture<void> future = QtConcurrent::run(&image, &QImage::invertPixels,QImage::InvertRgba);
future.waitForFinished();


总结：以上三种多线程的特点：

特征QThreadQRunnable和QThreadPoolQtConcurrent::run()

QtConcurrent

（Map，Filter，Reduce）

指定优先级是是

可运行

事件循环

是

线程可以通过

信号接收数据更新

是

可以使用

信号控制螺纹

是是（QFutureWatcher)

可以通过

QFuture监控线程

部分是是

内置暂停/

恢复/取消功能

是

适用场景：

生命周期开发任务解决方案
持续运行在另一个线程中重复执行昂贵的操作，其中线程不需要接收任何信号或事件。直接在QThread：：run()的重新实现中编写无限循环。在没有事件循环的情况下启动线程。让线程发出信号以将数据发送回 GUI 线程。
持续运行让一个对象存在于另一个线程中，该线程可以根据请求执行不同的任务和/或可以接收要使用的新数据。子类 一个QObject 以创建工作线程。实例化此工作线程对象和 QThread。将工作线程移动到新线程。通过排队的信号槽连接将命令或数据发送到工作器对象。
一次调用在另一个线程中运行新的线性函数，可以选择在运行期间更新进度。Qt提供不同的解决方案：
  • 将函数放在 QThread：：run（） 的重新实现中并启动 Qthread。发出信号以更新进度。或
  • 将函数放在 QRunnable：：run（） 的重新实现中，并将 QRunnable 添加到 QthreadPool 中。写入线程安全变量以更新进度。或
  • 使用 Q他Concurrent（） 运行函数。写入线程安全变量以更新进度。
一次调用在另一个线程中运行现有函数并获取其返回值。使用 QtConcurrent：：run（） 运行函数。让 QFutureWatcher 在函数返回时发出 done（） 信号，并调用 QFutureWatcher：：result（） 来获取函数的返回值。
一次调用使用所有可用核心对容器的所有项执行操作。例如，从图像列表生成缩略图。

使用 Qt Concurrent 的 QtConcurrent：：filter（） 函数选择容器元素，使用 QtConcurrent：：map（） 函数对每个元素应用操作。要将输出折叠成单个结果，请改用 QtConcurrent：：filteredReduction（） 和 QtConcurrent::mappedReduction（）。

参考文章：

Thread Support in Qt | Qt 5.15

 Qt线程之QRunnable的使用详解_luoyayun361的博客-CSDN博客_qrunnable 

【QT】继承QRunnable+QThreadPool实现多线程_李春港的博客-CSDN博客_继承qrunnable

Qt并发模块Qt Concurrent的使用_Amnesia Greens的博客-CSDN博客_qtconcurrent 


http://www.ppmy.cn/news/26841.html

相关文章

二、Plugin The chain/event/query function

二、Plugin The chain/event/query function

The chain function 链函数是所有数据处理都在其中进行的函数。在简单过滤器的情况下&#xff08;本节示例的情况&#xff09;&#xff0c;_chain()函数大多是线性函数——因此对于每个传入的缓冲区&#xff0c;也将输出一个缓冲区。下面是一个非常简单的chain函数的实现: sta…
阅读更多...
Java线程的6 种状态

Java线程的6 种状态

Java 线程的状态 Java线程有六种状态&#xff1a; 初始&#xff08;NEW&#xff09;、运行&#xff08;RUNNABLE&#xff09;、阻塞&#xff08;BLOCKED&#xff09;、 等待&#xff08;WAITING&#xff09;、超时等待&#xff08;TIMED_WAITING&#xff09;、终止&#xff08…
阅读更多...
【Spring6】| Spring启示录、Spring概述

【Spring6】| Spring启示录、Spring概述

目录 一&#xff1a;Spring启示录 1. OCP开闭原则 2. 依赖倒置原则DIP 3. 控制反转IoC 二&#xff1a;Spring概述 1. Spring简介 2. Spring8大模块 3. Spring特点 一&#xff1a;Spring启示录 引言&#xff1a;前面我们已经学习了三层架构&#xff1a;表示层、业务层、…
阅读更多...
使用 PyTorch+LSTM 进行单变量时间序列预测（附完整源码）

使用 PyTorch+LSTM 进行单变量时间序列预测（附完整源码）

时间序列是指在一段时间内发生的任何可量化的度量或事件。尽管这听起来微不足道&#xff0c;但几乎任何东西都可以被认为是时间序列。一个月里你每小时的平均心率&#xff0c;一年里一只股票的日收盘价&#xff0c;一年里某个城市每周发生的交通事故数。 在任何一段时间段内记…
阅读更多...
SQL零基础入门学习（四）

SQL零基础入门学习（四）

SQL零基础入门学习&#xff08;三&#xff09; SQL INSERT INTO 语句 INSERT INTO 语句用于向表中插入新记录。 SQL INSERT INTO 语法 INSERT INTO 语句可以有两种编写形式。 第一种形式无需指定要插入数据的列名&#xff0c;只需提供被插入的值即可&#xff1a; INSERT …
阅读更多...
基于Django的员工管理系统

基于Django的员工管理系统

目录 一、新建项目 二、创建app 三、设计表结构 四、在MySQL中生成表 五、静态文件管理 六、添加页面 七、模板的继承 一、新建项目 django-admin startproject 员工管理系统 二、创建app startapp app01 三、设计表结构 app01/migrations/models.py from django.db impo…
阅读更多...
K8s中gRpc通信负载均衡失效

K8s中gRpc通信负载均衡失效

上篇文章在做 整合K8sSpringCloudK8sSpringBootgRpc 时&#xff0c;发现K8s中使用gRpc通信&#xff0c;负载均衡功能失效查了下gRpc的最佳实践&#xff0c;找到这里Load balancingSome load balancers dont work effectively with gRPC. L4 (transport) load balancers operate…
阅读更多...
一月券商金工精选

一月券商金工精选

✦研报目录✦ ✦简述✦ 按发布时间排序 国盛证券 “薪火”量化分析系列研究&#xff08;二&#xff09;-票据逾期数据中的选股信息 发布日期&#xff1a;2023-01-04 关键词&#xff1a;股票、票据、票据预期 主要内容&#xff1a;本文深入探讨了“票据持续逾期名单”这一…
阅读更多...
最新文章

Copyright @ 2022~2023