Qt Concurrent框架详解（QFuture、QFutureWatcher）

1.概述

Qt Concurrent是Qt提供的一个并发编程框架，用于简化多线程和并行计算的开发。它提供了一组易于使用的函数和类，可以方便地在多线程环境下处理并发任务。

有以下特点：

简单易用：Qt Concurrent提供了一组高级函数和类，使多线程和并行计算变得简单易用。开发者无需显式地创建和管理线程，而是通过调用Qt Concurrent提供的函数实现并发任务。

自动任务分割：Qt Concurrent能够根据可用的线程数自动将大的问题拆分成更小的任务，并分配给不同的线程并行执行。这样能够最大程度地利用系统资源，提高并发执行效率。

异步计算：Qt Concurrent提供了异步执行任务的机制，可以在后台执行任务，同时不会阻塞主线程，从而提高用户界面的响应性。 主要的类和函数：

• QFuture：表示一个异步任务的未来结果。可以通过调用QFuture的result()方法来获取结果。还可以使用QFutureWatcher类来监视并处理异步任务的结果。
• QFutureIterator：用于遍历QFuture所代表的异步任务的结果集合。
• QThread：Qt Concurrent内部会自动管理线程，不需要手动创建和管理线程。但如果需要更细粒度的控制线程的操作，可以使用QThread类。
• QtConcurrent::run()：用于在后台线程执行函数。它会自动创建一个新的线程，并在该线程中执行指定的函数。
• QtConcurrent::map()：用于并行计算，将一个函数应用于一个容器中的每个元素，并返回结果集。它会根据可用的线程数自动进行任务分割和分配。
• QtConcurrent::filter()：根据指定的谓词函数，在容器中筛选符合条件的元素。也会进行任务分割和分配。
• QtConcurrent::blockingMapped()：与map类似，但是会阻塞当前线程直到所有任务完成。

2.常用方法

在 pro 文件添加“Qt += concurrent”并且在我们的 h 文件添加“#include <QtConcurrent>”，就可以使用这些函数了。基本上所有的 concurrent 函数分为三种类型：

• run 相关：执行函数用；
• map 相关：处理容器中的每一项；
• filter 相关：筛选容器中的每一项。

run方法：创建一个新的线程，并在该线程中执行指定的函数。

• QFuture<T> run(Function function, ...)
• QFuture<T> run(QThreadPool *pool, Function function, ...)

map方法：在单独的线程里对容器中的每一项进行操作，并返回结果集。

• QtConcurrent::map()：直接操作容器中的每一项。
• QtConcurrent::mapped()：操作容器中的每一项，将处理结果返回一个新的容器，原容器不变。
• QtConcurrent::mappedReduced()：在 mapped() 的基础上将处理结果进一步传递给一个函数继续处理。

filter方法：filter 相关函数和 map 相关函数类似，也是对容器中的元素进行处理，但 filter 更多侧重筛选元素。

• QtConcurrent::filter()
• QtConcurrent::filtered()
• QtConcurrent::filteredReduced()

3.示例

示例1：将普通函数运行在两个不同的线程中，使用QFuture的result()方法来获取返回结果。

#include <QApplication>
#include <QFuture>
#include <QtConcurrent>QString func1()
{qDebug()<<"我是func1函数";
}
QString func2(QString name)
{qDebug()<<"我是func2函数";return name;
}int main(int argc, char *argv[])
{QCoreApplication  a(argc, argv);//用QFuture获取该函数的运行结果QFuture<QString> fut1 = QtConcurrent::run(func1);//参数2：向func函数传递的参数QFuture<QString> fut2 = QtConcurrent::run(func2, QString("func2"));QString result2 = fut2.result();fut1.waitForFinished();fut2.waitForFinished();qDebug()<<"result2 = "<<result2;return a.exec();
}

运行结果：

示例2： 使用QtConcurrent::map()，QtConcurrent::mapped() ，QtConcurrent::mappedReduced()

map：直接操作容器中的每一项，不返回。

mapped：操作容器中的每一项，将处理结果返回一个新容器，原容器不变。

mappedReduced：mapped() 的基础上将处理结果进一步传递给下一个函数继续处理。

#include "mainwindow.h"
#include "ui_mainwindow.h"
#include <QDebug>
#include <QFuture>
#include <QtConcurrent>void processString1(QString& str) {str = str.toUpper();   //转大写
}QString processString2(const QString& str) {// 模拟一些复杂的处理逻辑QThread::msleep(1000);  // 延迟1秒return str.toUpper();   //转大写
}void processString3(QString &result, const QString &intermedia)
{result += " ";result += intermedia;
}MainWindow::MainWindow(QWidget *parent) :QMainWindow(parent),ui(new Ui::MainWindow)
{ui->setupUi(this);QStringList strings1 = {"hello", "world", "qt", "concurrent"};QFuture<void> fut1 = QtConcurrent::map(strings1, processString1);fut1.waitForFinished();qDebug()<<"==========result1=========";for(const QString& result : strings1) {qDebug() << result;}qDebug()<<"==========result1=========";qDebug()<<"==========result2=========";QStringList strings2 = {"hello", "world", "qt", "concurrent"};QFuture<QString> future = QtConcurrent::mapped(strings2, processString2);future.waitForFinished();QList<QString> results = future.results();for(const QString& result : results) {qDebug() << result;}qDebug()<<"==========result2=========";qDebug()<<"==========result3=========";QStringList strings3 = {"hello", "world", "qt", "concurrent"};QFuture<QString> future2 = QtConcurrent::mappedReduced(strings3, processString2,processString3);future2.waitForFinished();QList<QString> results2 = future2.results();for(const QString& results : results2) {qDebug() << results;}qDebug()<<"==========result3=========";
}MainWindow::~MainWindow()
{delete ui;
}

运行结果：

 示例3：使用QFutureWatcher来监视并处理异步任务的结果。

#include "mainwindow.h"
#include "ui_mainwindow.h"
#include <QDebug>
#include <QFuture>
#include <QtConcurrent>
#include <QFutureWatcher>QFutureWatcher<QStringList> watcher;QStringList processString(const QStringList& str) {// 模拟一些复杂的处理逻辑QThread::msleep(1000);  // 延迟1秒QStringList ret;for(int i=0;i<str.size();i++){ret.append(str.at(i).toUpper());}return ret;
}MainWindow::MainWindow(QWidget *parent) :QMainWindow(parent),ui(new Ui::MainWindow)
{ui->setupUi(this);QStringList strings = {"hello", "world", "qt", "concurrent"};QFuture<QStringList> future = QtConcurrent::run(processString, strings);watcher.setFuture(future);QObject::connect(&watcher, &QFutureWatcher<void>::finished, this, [&]() {qDebug() << "All tasks finished!";for(const QString& result2 : watcher.result()) {qDebug() << result2;}});QObject::connect(&watcher, &QFutureWatcher<void>::progressValueChanged, [](int value) {qDebug() << "Progress: " << value << "%";});}MainWindow::~MainWindow()
{delete ui;
}

运行结果：