Qt中的多线程_qt 多线程

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

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

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

QThreadPoo和QRunnable（实现的多线程）

QRunnable：

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

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

 使用的注意事项：

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

QRunnable和QThread的区别：

  

 QThreadPool（线程池）

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

线程池的优点：

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

常用函数： 

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

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

适用场景：

参考文章：

Thread Support in Qt | Qt 5.15

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

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

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