Qt提供了许多处理线程的类和函数。下面是Qt程序员可以用来实现多线程应用程序的四种不同方法。

QThread:带有可选事件循环的低级API

QThread是Qt中所有线程控制的基础，每个QThread实例代表并控制一个线程。
QThread既可以被直接实例化，也可以被子类化。实例化QThread提供了一个并行事件循环，允许在次要线程中调用QObject槽。子类化QThread允许应用程序在开始事件循环之前初始化新线程，或者在没有事件循环的情况下运行并行代码。

See the QThread class reference and the threading examples for demonstrations on how to use QThread.

QThreadPool和QRunnable:重用线程

频繁地创建和销毁线程的代价是昂贵的。为了减少这种开销，现有线程可以被新任务重用。QThreadPool是可重用的qthread的集合。

要在QThreadPool的某个线程中运行代码，请重新实现QRunnable::run()并实例化子类QRunnable。使用QThreadPool::start()将QRunnable放入QThreadPool的运行队列中。当线程可用时，QRunnable::run()中的代码将在该线程中执行。

每个Qt应用程序都有一个全局线程池，可以通过QThreadPool::globalInstance()来访问。这个全局线程池根据CPU中的核心数量自动维护最佳线程数量。但是，可以显式地创建和管理一个单独的QThreadPool。

class HelloWorldTask : public QRunnable
{void run() override{qDebug() << "Hello world from thread" << QThread::currentThread();}
};HelloWorldTask *hello = new HelloWorldTask();
// QThreadPool takes ownership and deletes 'hello' automatically
QThreadPool::globalInstance()->start(hello);

Qt Concurrent:使用高级API

Qt Concurrent模块提供了一些高级函数来处理一些常见的并行计算模式:map、filter和reduce。与使用QThread和QRunnable不同，这些函数从来不需要使用诸如互斥量或信号量之类的低级线程原语。相反，它们返回一个QFuture对象，当函数准备好时，该对象可用于检索函数的结果。QFuture还可以用于查询计算进度，暂停/恢复/取消计算。为了方便，QFutureWatcher允许通过信号和插槽与qfuture进行交互。

Qt Concurrent的map、filter和reduce算法自动地将计算分布到所有可用的处理器内核上，所以今天编写的应用程序在以后部署到更多内核的系统上时仍然可以扩展。

这个模块还提供了QtConcurrent::run()函数，它可以在另一个线程中运行任何函数。然而，QtConcurrent::run()只支持map、filter和reduce函数可用的功能子集。QFuture可用于获取函数的返回值，并检查线程是否正在运行。但是，对QtConcurrent::run()的调用只使用一个线程，不能被暂停/恢复/取消，也不能查询进度。

有关各个函数的详细信息，请参阅Qt Concurrent模块文档。

QtConcurrent::run：（在另一个线程中运行一个函数。）

// call 'void QImage::invertPixels(InvertMode mode)' in a separate thread
QImage image = ...;
QFuture<void> future = QtConcurrent::run(&image, &QImage::invertPixels, QImage::InvertRgba);
...
future.waitForFinished();
// At this point, the pixels in 'image' have been inverted

Qt Concurrent 支持多种兼容 STL 的容器和迭代器类型，但是最好使用具有随机访问迭代器的 Qt 容器，例如：QList 或 QVector。map 和 filter 函数都接受容器和 begin/end 迭代器。

Concurrent Map 和 Map-Reduce：多线程处理容器里的项

• QtConcurrent::map()：将一个函数应用于一个容器中的每一项，直接修改 items。

• QtConcurrent::mapped()：和 map() 类似，只是它返回一个包含修改内容的新容器。

• QtConcurrent::mappedReduced()：和 mapped() 类似，只是修改后的结果减少或组合成一个单一的结果。

函数模版格式：
U function(T &t);//T必须是容器里的类型，U必须是void(没有返回值和返回类型)例子：
void scale(QImage &image)
{image = image.scaled(100, 100);
}QList<QImage> images = ...;
QFuture<void> future = QtConcurrent::map(images, scale);

函数模版格式：
U function(const T &t);//T必须是容器里的类型，U可以任意类型（最终结果）例子：
QImage scaled(const QImage &image)
{return image.scaled(100, 100);
}QList<QImage> images = ...;//QList里的每张图片都会被缩放
QFuture<QImage> thumbnails = QtConcurrent::mapped(images, scaled);
//多个线程同时运行，每个结果通过QFuture返回。

函数模版：
V必须是void(没有返回值和返回类型)，T是mappedReduced后返回的结果(最终结果)，U是scaled函数的返回类型。
V function(T &result, const U &intermediate)QImage scaled(const QImage &image)
{return image.scaled(100, 100);
}void addToCollage(QImage &collage, const QImage &thumbnail)
{QPainter p(&collage);static QPoint offset = QPoint(0, 0);p.drawImage(offset, thumbnail);offset += ...;
}QList<QImage> images = ...;
//多个线程同时运算，addToCollage每次只有一个线程调用，所有是线程安全的
QFuture<QImage> collage = QtConcurrent::mappedReduced(images, scaled, addToCollage);
//理解：images对象调用scaled，scaled的结果通过addToCollage的第二个参数传递给addToCollage，addToCollage运算最终结果通过第一个参数返回。

同步模式，直接返回结果：

QList<QImage> images = ...;// Each call blocks until the entire operation is finished.
QList<QImage> future = QtConcurrent::blockingMapped(images, scaled);QtConcurrent::blockingMap(images, scale);QImage collage = QtConcurrent::blockingMappedReduced(images, scaled, addToCollage);

Concurrent Filter 和 Filter-Reduce：对容器里的项过滤后再多线程处理

• QtConcurrent::filter()：对结果进行筛选（根据筛选函数）。

• QtConcurrent::filtered()：和 filter() 类似，只是它返回一个包含过滤内容的新容器。

• QtConcurrent::filteredReduced()：和 filtered() 类似，只是过滤后的结果减少或组合成一个单一的结果。

//T必须匹配存储在序列中的类型。如果应该保留该项，则返回true;如果应该丢弃该项，则返回false。
bool function(const T &t);bool allLowerCase(const QString &string)
{return string.lowered() == string;
}QStringList strings = ...;
//对每一个项的结果都会执行过滤函数判断是否丢弃掉。
QFuture<QString> lowerCaseStrings = QtConcurrent::filtered(strings, allLowerCase);QStringList strings = ...;
QFuture<void> future = QtConcurrent::filter(strings, allLowerCase);

V是void(没有返回值和返回类型)，T是最终结果，U是被过滤项目的类型。
V function(T &result, const U &intermediate)void addToDictionary(QSet<QString> &dictionary, const QString &string)
{dictionary.insert(string);
}QStringList strings = ...;
//每个结果都经过addToDictionary筛选，通过第一个参数返回最终结果
//QtConcurrent::filteredReduced()保证一次只有一个线程调用reduce，所以没有必要使用互斥锁来锁定结果变量
QFuture<QSet<QString> > dictionary = QtConcurrent::filteredReduced(strings, allLowerCase, addToDictionary);

• QFuture：表示异步计算的结果

• QFutureIterator：允许通过 QFuture 遍历可用的结果

• QFutureWatcher：允许使用信号槽来监控一个 QFuture

• QFutureSynchronizer：是一个方便的类，用于一些 QFutures 的自动同步

// Instantiate the objects and connect to the finished signal.
MyClass myObject;
QFutureWatcher<int> watcher;
connect(&watcher, &QFutureWatcher<int>::finished, &myObject, &MyClass::handleFinished);// Start the computation.
QFuture<int> future = QtConcurrent::run(...);
watcher.setFuture(future);

void someFunction()
{QFutureSynchronizer<void> synchronizer;...synchronizer.addFuture(QtConcurrent::run(anotherFunction));synchronizer.addFuture(QtConcurrent::map(list, mapFunction));return; // QFutureSynchronizer waits for all futures to finish
}

WorkerScript: QML中的线程

WorkerScript QML类型允许JavaScript代码与GUI线程并行运行。

每个WorkerScript实例可以附加一个.js脚本。当WorkerScript.sendMessage()被调用时，脚本将在一个单独的线程(和一个单独的QML上下文)中运行。当脚本完成运行时，它可以将应答发送回GUI线程，该线程将调用WorkerScript.onMessage()信号处理程序。

使用WorkerScript类似于使用已移动到另一个线程的worker QObject。数据通过信号在线程之间传输。

有关如何实现脚本的详细信息，以及可以在线程之间传递的数据类型列表，请参阅WorkerScript文档。

选择合适的方案

如上所述，Qt为开发线程应用程序提供了不同的解决方案。给定应用程序的正确解决方案取决于新线程的目的和线程的生命周期。下面是Qt线程技术的比较，然后是一些示例用例的推荐解决方案。

方案的比较

Feature	QThread	QRunnable and QThreadPool	QtConcurrent::run()	Qt Concurrent (Map, Filter, Reduce)	WorkerScript
语言	C++	C++	C++	C++	QML
可以指定线程优先级	Yes	Yes
线程可以运行事件循环	Yes
线程可以通过信号接收数据更新	Yes (received by a worker QObject)				Yes (received by WorkerScript)
线程可以使用信号来控制	Yes (received by QThread)			Yes (received by QFutureWatcher)
线程可以通过QFuture来监控			Partially	Yes
内置暂停/恢复/取消功能				Yes

用例

线程寿命	Operation	Solution
一次	在另一个线程中运行一个新的线性函数，可以选择在运行期间进行进度更新。	Qt提供了不同的解决方案: 将函数放在QThread::run()的重新实现中，并启动QThread。发送信号来更新进度。或 将函数放在QRunnable::run()的重新实现中，并将QRunnable添加到QThreadPool中。写入线程安全的变量以更新进度。或 使用QtConcurrent:: Run()运行函数。写入线程安全的变量以更新进度。
一次	在另一个线程中运行现有函数并获取其返回值。	使用QtConcurrent:: Run()运行函数。让QFutureWatcher在函数返回时发出finished()信号，并调用QFutureWatcher::result()来获取函数的返回值。
一次	对容器的所有项执行操作，使用所有可用的内核。例如，从图像列表生成缩略图。	使用QtConcurrent的QtConcurrent::filter()函数选择容器元素，使用QtConcurrent::map()函数对每个元素应用操作。要将输出折叠为单个结果，请使用QtConcurrent::filteredReduced()和QtConcurrent::mappedReduced()。
一次/永久	在纯QML应用程序中执行长时间的计算，并在结果准备好时更新GUI。	将计算代码放在。js脚本中，并将其附加到WorkerScript实例。调用WorkerScript.sendMessage()在新线程中开始计算。让脚本也调用sendMessage()，将结果传递回GUI线程。在onMessage中处理结果并更新GUI。
永久	让一个对象驻留在另一个线程中，该线程可以根据请求执行不同的任务和/或可以接收新数据来处理。	子类化一个QObject来创建一个worker。实例化这个worker对象和一个QThread。将工作线程移动到新线程。通过排队信号槽连接向工作对象发送命令或数据。
永久	在另一个线程中重复执行昂贵的操作，其中线程不需要接收任何信号或事件。	直接在QThread::run()的重新实现中编写无限循环。启动不使用事件循环的线程。让线程发出信号，将数据发送回GUI线程。

Thread Support in Qt | Qt 5.15

Multithreading Technologies in Qt | Qt 5.15