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();  

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

特征	QThread	QRunnable和QThreadPool	QtConcurrent::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