QtConcurrent Namespace

QtConcurrent 命名空间提供了高级 API，无需使用底层线程原语即可编写多线程程序。更多

Header：	`#include <QtConcurrent>`
CMake：	`find_package(Qt6 REQUIRED COMPONENTS Concurrent)` `target_link_libraries(mytarget PRIVATE Qt6::Concurrent)`
qmake.QtConcurrent 是线程类的一部分：	`QT += concurrent`

QtConcurrent 是线程类的一部分。

类

(since 6.0) class QTaskBuilder

类型

enum class	FutureResult { Ignore }
	InvokeResultType
enum	ReduceOption { UnorderedReduce, OrderedReduce, SequentialReduce }
flags	ReduceOptions

函数

void	blockingFilter(Sequence &sequence, KeepFunctor &&filterFunction)
void	blockingFilter(QThreadPool *pool, Sequence &sequence, KeepFunctor &&filterFunction)
std::decay_t<Sequence>	blockingFiltered(Sequence &&sequence, KeepFunctor &&filterFunction)
OutputSequence	blockingFiltered(Iterator begin, Iterator end, KeepFunctor &&filterFunction)
std::decay_t<Sequence>	blockingFiltered(QThreadPool *pool, Sequence &&sequence, KeepFunctor &&filterFunction)
OutputSequence	blockingFiltered(QThreadPool *pool, Iterator begin, Iterator end, KeepFunctor &&filterFunction)
ResultType	blockingFilteredReduced(Sequence &&sequence, KeepFunctor &&filterFunction, ReduceFunctor &&reduceFunction, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce \| SequentialReduce))
ResultType	blockingFilteredReduced(Iterator begin, Iterator end, KeepFunctor &&filterFunction, ReduceFunctor &&reduceFunction, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce \| SequentialReduce))
ResultType	blockingFilteredReduced(QThreadPool *pool, Sequence &&sequence, KeepFunctor &&filterFunction, ReduceFunctor &&reduceFunction, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce \| SequentialReduce))
ResultType	blockingFilteredReduced(Sequence &&sequence, KeepFunctor &&filterFunction, ReduceFunctor &&reduceFunction, InitialValueType &&initialValue, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce \| SequentialReduce))
ResultType	blockingFilteredReduced(Iterator begin, Iterator end, KeepFunctor &&filterFunction, ReduceFunctor &&reduceFunction, InitialValueType &&initialValue, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce \| SequentialReduce))
ResultType	blockingFilteredReduced(QThreadPool *pool, Iterator begin, Iterator end, KeepFunctor &&filterFunction, ReduceFunctor &&reduceFunction, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce \| SequentialReduce))
ResultType	blockingFilteredReduced(QThreadPool *pool, Sequence &&sequence, KeepFunctor &&filterFunction, ReduceFunctor &&reduceFunction, InitialValueType &&initialValue, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce \| SequentialReduce))
ResultType	blockingFilteredReduced(QThreadPool *pool, Iterator begin, Iterator end, KeepFunctor &&filterFunction, ReduceFunctor &&reduceFunction, InitialValueType &&initialValue, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce \| SequentialReduce))
void	blockingMap(Sequence &&sequence, MapFunctor &&function)
void	blockingMap(Iterator begin, Iterator end, MapFunctor &&function)
void	blockingMap(QThreadPool *pool, Sequence &&sequence, MapFunctor function)
void	blockingMap(QThreadPool *pool, Iterator begin, Iterator end, MapFunctor &&function)
OutputSequence	blockingMapped(InputSequence &&sequence, MapFunctor &&function)
Sequence	blockingMapped(Iterator begin, Iterator end, MapFunctor &&function)
OutputSequence	blockingMapped(QThreadPool *pool, InputSequence &&sequence, MapFunctor &&function)
Sequence	blockingMapped(QThreadPool *pool, Iterator begin, Iterator end, MapFunctor &&function)
ResultType	blockingMappedReduced(Sequence &&sequence, MapFunctor &&mapFunction, ReduceFunctor &&reduceFunction, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce \| SequentialReduce))
ResultType	blockingMappedReduced(Iterator begin, Iterator end, MapFunctor &&mapFunction, ReduceFunctor &&reduceFunction, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce \| SequentialReduce))
ResultType	blockingMappedReduced(QThreadPool *pool, Sequence &&sequence, MapFunctor &&mapFunction, ReduceFunctor &&reduceFunction, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce \| SequentialReduce))
ResultType	blockingMappedReduced(Sequence &&sequence, MapFunctor &&mapFunction, ReduceFunctor &&reduceFunction, InitialValueType &&initialValue, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce \| SequentialReduce))
ResultType	blockingMappedReduced(Iterator begin, Iterator end, MapFunctor &&mapFunction, ReduceFunctor &&reduceFunction, InitialValueType &&initialValue, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce \| SequentialReduce))
ResultType	blockingMappedReduced(QThreadPool *pool, Iterator begin, Iterator end, MapFunctor &&mapFunction, ReduceFunctor &&reduceFunction, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce \| SequentialReduce))
ResultType	blockingMappedReduced(QThreadPool *pool, Sequence &&sequence, MapFunctor &&mapFunction, ReduceFunctor &&reduceFunction, InitialValueType &&initialValue, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce \| SequentialReduce))
ResultType	blockingMappedReduced(QThreadPool *pool, Iterator begin, Iterator end, MapFunctor &&mapFunction, ReduceFunctor &&reduceFunction, InitialValueType &&initialValue, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce \| SequentialReduce))
QFuture<void>	filter(Sequence &sequence, KeepFunctor &&filterFunction)
QFuture<void>	filter(QThreadPool *pool, Sequence &sequence, KeepFunctor &&filterFunction)
QFuture<typename std::decay_t<Sequence>::value_type>	filtered(Sequence &&sequence, KeepFunctor &&filterFunction)
QFuture<typename qValueType<Iterator>::value_type>	filtered(Iterator begin, Iterator end, KeepFunctor &&filterFunction)
QFuture<typename std::decay_t<Sequence>::value_type>	filtered(QThreadPool *pool, Sequence &&sequence, KeepFunctor &&filterFunction)
QFuture<typename qValueType<Iterator>::value_type>	filtered(QThreadPool *pool, Iterator begin, Iterator end, KeepFunctor &&filterFunction)
QFuture<ResultType>	filteredReduced(Sequence &&sequence, KeepFunctor &&filterFunction, ReduceFunctor &&reduceFunction, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce \| SequentialReduce))
QFuture<ResultType>	filteredReduced(Iterator begin, Iterator end, KeepFunctor &&filterFunction, ReduceFunctor &&reduceFunction, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce \| SequentialReduce))
QFuture<ResultType>	filteredReduced(QThreadPool *pool, Sequence &&sequence, KeepFunctor &&filterFunction, ReduceFunctor &&reduceFunction, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce \| SequentialReduce))
QFuture<ResultType>	filteredReduced(Sequence &&sequence, KeepFunctor &&filterFunction, ReduceFunctor &&reduceFunction, InitialValueType &&initialValue, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce \| SequentialReduce))
QFuture<ResultType>	filteredReduced(Iterator begin, Iterator end, KeepFunctor &&filterFunction, ReduceFunctor &&reduceFunction, InitialValueType &&initialValue, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce \| SequentialReduce))
QFuture<ResultType>	filteredReduced(QThreadPool *pool, Iterator begin, Iterator end, KeepFunctor &&filterFunction, ReduceFunctor &&reduceFunction, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce \| SequentialReduce))
QFuture<ResultType>	filteredReduced(QThreadPool *pool, Sequence &&sequence, KeepFunctor &&filterFunction, ReduceFunctor &&reduceFunction, InitialValueType &&initialValue, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce \| SequentialReduce))
QFuture<ResultType>	filteredReduced(QThreadPool *pool, Iterator begin, Iterator end, KeepFunctor &&filterFunction, ReduceFunctor &&reduceFunction, InitialValueType &&initialValue, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce \| SequentialReduce))
QFuture<void>	map(Sequence &&sequence, MapFunctor &&function)
QFuture<void>	map(Iterator begin, Iterator end, MapFunctor &&function)
QFuture<void>	map(QThreadPool *pool, Sequence &&sequence, MapFunctor &&function)
QFuture<void>	map(QThreadPool *pool, Iterator begin, Iterator end, MapFunctor &&function)
QFuture<QtPrivate::MapResultType<Sequence, MapFunctor>>	mapped(Sequence &&sequence, MapFunctor &&function)
QFuture<QtPrivate::MapResultType<Iterator, MapFunctor>>	mapped(Iterator begin, Iterator end, MapFunctor &&function)
QFuture<QtPrivate::MapResultType<Sequence, MapFunctor>>	mapped(QThreadPool *pool, Sequence &&sequence, MapFunctor &&function)
QFuture<QtPrivate::MapResultType<Iterator, MapFunctor>>	mapped(QThreadPool *pool, Iterator begin, Iterator end, MapFunctor &&function)
QFuture<ResultType>	mappedReduced(Sequence &&sequence, MapFunctor &&mapFunction, ReduceFunctor &&reduceFunction, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce \| SequentialReduce))
QFuture<ResultType>	mappedReduced(Iterator begin, Iterator end, MapFunctor &&mapFunction, ReduceFunctor &&reduceFunction, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce \| SequentialReduce))
QFuture<ResultType>	mappedReduced(QThreadPool *pool, Sequence &&sequence, MapFunctor &&mapFunction, ReduceFunctor &&reduceFunction, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce \| SequentialReduce))
QFuture<ResultType>	mappedReduced(Sequence &&sequence, MapFunctor &&mapFunction, ReduceFunctor &&reduceFunction, InitialValueType &&initialValue, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce \| SequentialReduce))
QFuture<ResultType>	mappedReduced(Iterator begin, Iterator end, MapFunctor &&mapFunction, ReduceFunctor &&reduceFunction, InitialValueType &&initialValue, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce \| SequentialReduce))
QFuture<ResultType>	mappedReduced(QThreadPool *pool, Iterator begin, Iterator end, MapFunctor &&mapFunction, ReduceFunctor &&reduceFunction, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce \| SequentialReduce))
QFuture<ResultType>	mappedReduced(QThreadPool *pool, Sequence &&sequence, MapFunctor &&mapFunction, ReduceFunctor &&reduceFunction, InitialValueType &&initialValue, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce \| SequentialReduce))
QFuture<ResultType>	mappedReduced(QThreadPool *pool, Iterator begin, Iterator end, MapFunctor &&mapFunction, ReduceFunctor &&reduceFunction, InitialValueType &&initialValue, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce \| SequentialReduce))
QFuture<T>	run(Function function, ...)
QFuture<T>	run(QThreadPool *pool, Function function, ...)
`(since 6.0)` QtConcurrent::QTaskBuilder<Task>	task(Task &&task)

详细说明

请参阅 Qt Concurrent模块文档，了解可用函数的概述，或查看下文，了解每个函数的详细信息。

类

类QTaskBuilder

QTaskBuilder 类用于调整任务参数。更多

类型文档

enum class QtConcurrent::FutureResult

该枚举类型用于调用不返回未来对象的QtConcurrent::QTaskBuilder::spawn(QtConcurrent::FutureResult) 的特殊重载。

常量	值	描述
`QtConcurrent::FutureResult::Ignore`	`0`	为提高代码可读性而引入的辅助标记。

`[alias]` InvokeResultType

该类型的简化定义如下：

template <class Task, class ...Args>
using InvokeResultType = std::invoke_result_t<std::decay_t<Task>, std::decay_t<Args>...>;

真正的实现还包含一个编译时检查，检查是否可以使用指定的参数调用任务。

枚举 QtConcurrent::ReduceOption
flags QtConcurrent::ReduceOptions

该枚举指定了 map 或 filter 函数的结果传递给 reduce 函数的顺序。

常量	值	说明
`QtConcurrent::UnorderedReduce`	`0x1`	以任意顺序还原。
`QtConcurrent::OrderedReduce`	`0x2`	按照原始序列的顺序进行还原。
`QtConcurrent::SequentialReduce`	`0x4`	顺序还原：每次只有一个线程进入还原函数。(Qt Concurrent 的未来版本可能会支持并行还原）。

ReduceOptions 类型是QFlags<ReduceOption> 的类型定义。它存储 ReduceOption 值的 OR 组合。

函数文档

template <typename Sequence, typename KeepFunctor> void QtConcurrent::blockingFilter(Sequence &sequence, KeepFunctor &&filterFunction)

对sequence 中的每个项目调用一次filterFunction 。如果filterFunction 返回true ，项目将保留在sequence 中；否则，项目将从sequence 中删除。

请注意，此方法没有处理迭代器的重载，因为它会使所操作序列的迭代器无效。

注意： 此函数将阻塞，直到序列中的所有项目都已处理完毕。

另请参阅 并发过滤器和过滤器-还原。

template <typename Sequence, typename KeepFunctor> void QtConcurrent::blockingFilter(QThreadPool **pool, Sequence &sequence, KeepFunctor &&filterFunction*)

sequence 中的每个项目调用filterFunction 一次。对filterFunction 的所有调用都是从QThreadPool pool 的线程中调用的。如果filterFunction 返回true ，项目将保留在sequence 中；否则，项目将从sequence 中移除。

请注意，此方法没有处理迭代器的重载，因为它会使所操作序列的迭代器失效。

注意： 此函数将阻塞，直到序列中的所有项目都已处理完毕。

另请参阅 并发过滤器和过滤器-还原。

template <typename Sequence, typename KeepFunctor> std::decay_t<Sequence> QtConcurrent::blockingFiltered(Sequence &&sequence, KeepFunctor &&filterFunction)

对sequence 中的每个项目调用一次filterFunction ，并返回一个新的保留项目序列。如果filterFunction 返回true ，项目的副本将被放入新序列。否则，项目不会出现在新的序列中。

注意： 此函数将阻塞，直到序列中的所有项目都已处理完毕。

另请参阅 filtered() 以及并发过滤和过滤-还原。

template <typename OutputSequence, typename Iterator, typename KeepFunctor> OutputSequence QtConcurrent::blockingFiltered(Iterator begin, Iterator end, KeepFunctor &&filterFunction)

从begin 到end 的每个项目调用一次filterFunction ，并返回一个新的保留项目序列。如果filterFunction 返回true ，则该项目副本将被放入新序列。否则，该项目不会出现在新的序列中。

注意： 此函数将阻塞，直到迭代器到达正在处理的序列的末尾。

另请参阅 filtered() 以及并发过滤和过滤-还原。

template <typename Sequence, typename KeepFunctor> std::decay_t<Sequence> QtConcurrent::blockingFiltered(QThreadPool **pool, Sequence &&sequence, KeepFunctor &&filterFunction*)

sequence 中的每个项目调用filterFunction 一次，并返回一个新的保留项目序列。对filterFunction 的所有调用都是从QThreadPool pool 的线程中调用的。如果filterFunction 返回true ，该项目副本将被放入新序列。否则，项目将不会出现在新序列中。

注意： 此函数将阻塞，直到序列中的所有项目都已处理完毕。

另请参阅 filtered() 以及并发过滤和过滤-还原。

template <typename OutputSequence, typename Iterator, typename KeepFunctor> OutputSequence QtConcurrent::blockingFiltered(QThreadPool **pool, Iterator begin, Iterator end, KeepFunctor &&filterFunction*)

从begin 到end ，每个项目调用一次filterFunction ，并返回一个新的保留项目序列。对filterFunction 的所有调用都是从QThreadPool pool 的线程中调用的。如果filterFunction 返回true ，则该项目副本将放入新序列。否则，项目将不会出现在新序列中。

注意： 此函数将阻塞，直到迭代器到达正在处理的序列的末尾。

另请参阅 filtered() 以及并发过滤和过滤-还原。

template <typename ResultType, typename Sequence, typename KeepFunctor, typename ReduceFunctor> ResultType QtConcurrent::blockingFilteredReduced(Sequence &&sequence, KeepFunctor &&filterFunction, ReduceFunctor &&reduceFunction, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))

对sequence 中的每个项目调用一次filterFunction 。如果filterFunction 对某个项目返回true ，则该项目将被传递给reduceFunction 。换句话说，返回值是reduceFunction 对filterFunction 返回true 的每个项目的结果。

请注意，当filterFunction 被并发调用时，每次只有一个线程会调用reduceFunction 。如果reduceOptions 是QtConcurrent::UnorderedReduce ，则调用reduceFunction 的顺序未定义。如果reduceOptions 是QtConcurrent::OrderedReduce ，则调用reduceFunction 的顺序与原始序列一致。

注意： 此函数将阻塞，直到序列中的所有项目都已处理完毕。

另请参阅 filteredReduced() 以及并发过滤和过滤-还原。

template <typename ResultType, typename Iterator, typename KeepFunctor, typename ReduceFunctor> ResultType QtConcurrent::blockingFilteredReduced(Iterator begin, Iterator end, KeepFunctor &&filterFunction, ReduceFunctor &&reduceFunction, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))

从begin 到end ，每个项目都调用一次filterFunction 。如果filterFunction 对某个项目返回true ，则该项目将被传递给reduceFunction 。换句话说，对于filterFunction 对true 返回的每个项目，返回值都是reduceFunction 的结果。

注意： 此函数将阻塞，直到迭代器到达正在处理的序列的末尾。

另请参阅 filteredReduced() 以及并发过滤和过滤-还原。

template <typename ResultType, typename Sequence, typename KeepFunctor, typename ReduceFunctor> ResultType QtConcurrent::blockingFilteredReduced(QThreadPool **pool, Sequence &&sequence, KeepFunctor &&filterFunction, ReduceFunctor &&reduceFunction, QtConcurrent::ReduceOptions reduceOptions* = ReduceOptions(UnorderedReduce | SequentialReduce))

sequence 中的每个项目调用filterFunction 一次。对filterFunction 的所有调用都是从QThreadPool pool 的线程中调用的。如果filterFunction 返回某个项目的true ，则该项目将被传递给reduceFunction 。换句话说，对于filterFunction 返回true 的每个项目，返回值都是reduceFunction 的结果。

注意： 此函数将阻塞，直到序列中的所有项目都已处理完毕。

另请参阅 filteredReduced() 以及并发过滤和过滤-还原。

template <typename ResultType, typename Sequence, typename KeepFunctor, typename ReduceFunctor, typename InitialValueType> ResultType QtConcurrent::blockingFilteredReduced(Sequence &&sequence, KeepFunctor &&filterFunction, ReduceFunctor &&reduceFunction, InitialValueType &&initialValue, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))

对sequence 中的每个项目调用一次filterFunction 。如果filterFunction 对某个项目返回true ，则该项目将被传递给reduceFunction 。换句话说，对filterFunction 对true 返回的每个项目，返回值都是reduceFunction 的结果。调用函数时，结果值初始化为initialValue ，对reduceFunction 的第一次调用将对该值进行操作。

请注意，在并发调用filterFunction 时，每次只有一个线程调用reduceFunction 。如果reduceOptions 是QtConcurrent::UnorderedReduce ，则调用reduceFunction 的顺序未定义。如果reduceOptions 是QtConcurrent::OrderedReduce ，则调用reduceFunction 的顺序与原始顺序一致。

注意： 此函数将阻塞，直到序列中的所有项目都已处理完毕。

另请参阅 filteredReduced() 以及并发过滤和过滤-还原。

template <typename ResultType, typename Iterator, typename KeepFunctor, typename ReduceFunctor, typename InitialValueType> ResultType QtConcurrent::blockingFilteredReduced(Iterator begin, Iterator end, KeepFunctor &&filterFunction, ReduceFunctor &&reduceFunction, InitialValueType &&initialValue, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))

从begin 到end ，每个项目都调用一次filterFunction 。如果filterFunction 对某个项目返回true ，则该项目将被传递到reduceFunction 。换句话说，对于filterFunction 对true 返回的每个项目，返回值都是reduceFunction 的结果。调用函数时，结果值初始化为initialValue ，对reduceFunction 的第一次调用将对该值进行操作。

注意： 此函数将阻塞，直到迭代器到达正在处理的序列的末尾。

另请参阅 filteredReduced() 以及并发过滤和过滤-还原。

template <typename ResultType, typename Iterator, typename KeepFunctor, typename ReduceFunctor> ResultType QtConcurrent::blockingFilteredReduced(QThreadPool **pool, Iterator begin, Iterator end, KeepFunctor &&filterFunction, ReduceFunctor &&reduceFunction, QtConcurrent::ReduceOptions reduceOptions* = ReduceOptions(UnorderedReduce | SequentialReduce))

从begin 到end ，每个项目调用一次filterFunction 。对filterFunction 的所有调用都是从QThreadPool pool 的线程中调用的。如果filterFunction 返回某个项目的true ，则该项目将被传递给reduceFunction 。换句话说，对于filterFunction 返回true 的每个项目，返回值都是reduceFunction 的结果。

注意： 此函数将阻塞，直到迭代器到达正在处理的序列的末尾。

另请参阅 filteredReduced() 以及并发过滤和过滤-还原。

template <typename ResultType, typename Sequence, typename KeepFunctor, typename ReduceFunctor, typename InitialValueType> ResultType QtConcurrent::blockingFilteredReduced(QThreadPool **pool, Sequence &&sequence, KeepFunctor &&filterFunction, ReduceFunctor &&reduceFunction, InitialValueType &&initialValue, QtConcurrent::ReduceOptions reduceOptions* = ReduceOptions(UnorderedReduce | SequentialReduce))

注意： 此函数将阻塞，直到序列中的所有项目都已处理完毕。

另请参阅 filteredReduced() 以及并发过滤和过滤-还原。

template <typename ResultType, typename Iterator, typename KeepFunctor, typename ReduceFunctor, typename InitialValueType> ResultType QtConcurrent::blockingFilteredReduced(QThreadPool **pool, Iterator begin, Iterator end, KeepFunctor &&filterFunction, ReduceFunctor &&reduceFunction, InitialValueType &&initialValue, QtConcurrent::ReduceOptions reduceOptions* = ReduceOptions(UnorderedReduce | SequentialReduce))

注意： 此函数将阻塞，直到迭代器到达正在处理的序列的末尾。

另请参阅 filteredReduced() 以及并发过滤和过滤-还原。

template <typename Sequence, typename MapFunctor> void QtConcurrent::blockingMap(Sequence &&sequence, MapFunctor &&function)

sequence 中的每个项目调用一次function 。function 获取项目的引用，因此对项目所做的任何修改都将显示在sequence 中。

注意： 此函数将阻塞，直到序列中的所有项目都已处理完毕。

另请参阅 map() 以及并发 Map 和 Map-Reduce。

template <typename Iterator, typename MapFunctor> void QtConcurrent::blockingMap(Iterator begin, Iterator end, MapFunctor &&function)

从begin 到end ，每个项目调用一次function 。function 获取项目的引用，因此对项目所做的任何修改都将出现在迭代器所属的序列中。

注意： 此函数将阻塞，直到迭代器到达正在处理的序列的末尾。

另请参阅 map() 以及并发 Map 和 Map-Reduce。

template <typename Sequence, typename MapFunctor> void QtConcurrent::blockingMap(QThreadPool **pool, Sequence &&sequence, MapFunctor function*)

sequence 中的每个项目调用function 一次。对function 的所有调用都是从QThreadPool pool 的线程中调用的。function 会获取项目的引用，因此对项目所做的任何修改都会显示在sequence 中。

注意： 此函数将阻塞，直到序列中的所有项目都已处理完毕。

另请参阅 map() 以及并发 Map 和 Map-Reduce。

template <typename Iterator, typename MapFunctor> void QtConcurrent::blockingMap(QThreadPool **pool, Iterator begin, Iterator end, MapFunctor &&function*)

从begin 到end ，每个项目调用一次function 。对function 的所有调用都是从QThreadPool pool 的线程中调用的。function 会获取项目的引用，因此对项目所做的任何修改都会出现在迭代器所属的序列中。

注意： 此函数将阻塞，直到迭代器到达正在处理的序列的末尾。

另请参阅 map() 以及并发 Map 和 Map-Reduce。

template <typename OutputSequence, typename InputSequence, typename MapFunctor> OutputSequence QtConcurrent::blockingMapped(InputSequence &&sequence, MapFunctor &&function)

对sequence 中的每个项目调用一次function ，并返回一个包含结果的 OutputSequence。结果的类型将与 MapFunctor 返回的类型一致。

注意： 此函数将阻塞，直到序列中的所有项目都已处理完毕。

另请参阅 mapped() 以及并发 Map 和 Map-Reduce。

template <typename Sequence, typename Iterator, typename MapFunctor> Sequence QtConcurrent::blockingMapped(Iterator begin, Iterator end, MapFunctor &&function)

对begin 到end 的每个项目调用function 一次，并返回一个包含结果的容器。您可以将容器类型指定为模板参数，如下所示：

QList<int> ints = QtConcurrent::blockingMapped<QList<int> >(beginIterator, endIterator, fn);

注意： 此函数将阻塞，直到迭代器到达正在处理的序列的末尾。

另请参阅 mapped() 以及并发 Map 和 Map-Reduce。

template <typename OutputSequence, typename InputSequence, typename MapFunctor> OutputSequence QtConcurrent::blockingMapped(QThreadPool **pool, InputSequence &&sequence, MapFunctor &&function*)

sequence 中的每个项目调用function 一次，并返回一个包含结果的 OutputSequence。对function 的所有调用都是从QThreadPool pool 的线程中调用的。结果的类型将与 MapFunctor 返回的类型一致。

注意： 此函数将阻塞，直到序列中的所有项目都已处理完毕。

另请参阅 mapped() 以及并发 Map 和 Map-Reduce。

template <typename Sequence, typename Iterator, typename MapFunctor> Sequence QtConcurrent::blockingMapped(QThreadPool **pool, Iterator begin, Iterator end, MapFunctor &&function*)

从begin 到end ，每个项目调用一次function ，并返回一个包含结果的容器。对function 的所有调用都是从QThreadPool pool 的线程中调用的。您可以将容器的类型指定为模板参数，如下所示：

QList<int> ints = QtConcurrent::blockingMapped<QList<int> >(beginIterator, endIterator, fn);

注意： 此函数将阻塞，直到迭代器到达正在处理的序列的末尾。

另请参阅 mapped() 以及并发 Map 和 Map-Reduce。

template <typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor> ResultType QtConcurrent::blockingMappedReduced(Sequence &&sequence, MapFunctor &&mapFunction, ReduceFunctor &&reduceFunction, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))

sequence 中的每个项目调用mapFunction 一次。每个mapFunction 的返回值都会传递给reduceFunction 。

请注意，虽然mapFunction 被并发调用，但每次只有一个线程调用reduceFunction 。调用reduceFunction 的顺序由reduceOptions 决定。

注意： 该函数将阻塞，直到序列中的所有项目都已处理完毕。

另请参阅 mapped() 以及并发 Map 和 Map-Reduce。

template <typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor> ResultType QtConcurrent::blockingMappedReduced(Iterator begin, Iterator end, MapFunctor &&mapFunction, ReduceFunctor &&reduceFunction, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))

从begin 到end ，每个项目都会调用一次mapFunction 。每次mapFunction 的返回值都会传递给reduceFunction 。

请注意，当mapFunction 被并发调用时，每次只有一个线程会调用reduceFunction 。调用reduceFunction 的顺序未定义。

注意： 该函数将阻塞，直到迭代器到达正在处理的序列的末尾。

另请参阅 blockingMappedReduced() 以及并发 Map 和 Map-Reduce。

template <typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor> ResultType QtConcurrent::blockingMappedReduced(QThreadPool **pool, Sequence &&sequence, MapFunctor &&mapFunction, ReduceFunctor &&reduceFunction, QtConcurrent::ReduceOptions reduceOptions* = ReduceOptions(UnorderedReduce | SequentialReduce))

sequence 中的每个项目调用mapFunction 一次。对mapFunction 的所有调用都是从QThreadPool pool 的线程中调用的。每个mapFunction 的返回值都会传递给reduceFunction 。

请注意，虽然mapFunction 会被并发调用，但每次只有一个线程会调用reduceFunction 。调用reduceFunction 的顺序由reduceOptions 决定。

注意： 该函数将阻塞，直到序列中的所有项目都已处理完毕。

另请参阅 mapped() 以及并发 Map 和 Map-Reduce。

template <typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor, typename InitialValueType> ResultType QtConcurrent::blockingMappedReduced(Sequence &&sequence, MapFunctor &&mapFunction, ReduceFunctor &&reduceFunction, InitialValueType &&initialValue, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))

sequence 中的每个项目调用mapFunction 一次。每个mapFunction 的返回值都会传递给reduceFunction 。调用函数时，结果值初始化为initialValue ，对reduceFunction 的第一次调用将对该值进行操作。

请注意，在并发调用mapFunction 时，每次只有一个线程调用reduceFunction 。调用reduceFunction 的顺序由reduceOptions 决定。

注意： 该函数将阻塞，直到序列中的所有项目都已处理完毕。

另请参阅 mapped() 以及并发 Map 和 Map-Reduce。

template <typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor, typename InitialValueType> ResultType QtConcurrent::blockingMappedReduced(Iterator begin, Iterator end, MapFunctor &&mapFunction, ReduceFunctor &&reduceFunction, InitialValueType &&initialValue, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))

从begin 到end ，每个项目都会调用一次mapFunction 。每次mapFunction 的返回值都会传递给reduceFunction 。调用该函数时，结果值被初始化为initialValue ，对reduceFunction 的第一次调用将对该值进行操作。

请注意，当mapFunction 被并发调用时，每次只有一个线程会调用reduceFunction 。调用reduceFunction 的顺序未定义。

注意： 此函数将阻塞，直到迭代器到达正在处理的序列的末尾。

另请参阅 blockingMappedReduced() 以及并发 Map 和 Map-Reduce。

template <typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor> ResultType QtConcurrent::blockingMappedReduced(QThreadPool **pool, Iterator begin, Iterator end, MapFunctor &&mapFunction, ReduceFunctor &&reduceFunction, QtConcurrent::ReduceOptions reduceOptions* = ReduceOptions(UnorderedReduce | SequentialReduce))

从begin 到end ，每个项目调用一次mapFunction 。对mapFunction 的所有调用都是从QThreadPool pool 的线程中调用的。每个mapFunction 的返回值都会传递给reduceFunction 。

请注意，虽然mapFunction 被并发调用，但每次只有一个线程调用reduceFunction 。调用reduceFunction 的顺序未定义。

注意： 此函数将阻塞，直到迭代器到达正在处理的序列的末尾。

另请参阅 blockingMappedReduced() 以及并发 Map 和 Map-Reduce。

template <typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor, typename InitialValueType> ResultType QtConcurrent::blockingMappedReduced(QThreadPool **pool, Sequence &&sequence, MapFunctor &&mapFunction, ReduceFunctor &&reduceFunction, InitialValueType &&initialValue, QtConcurrent::ReduceOptions reduceOptions* = ReduceOptions(UnorderedReduce | SequentialReduce))

sequence 中的每个项目调用mapFunction 一次。对mapFunction 的所有调用都是从QThreadPool pool 的线程中调用的。每个mapFunction 的返回值都会传递给reduceFunction 。在调用函数时，结果值被初始化为initialValue ，对reduceFunction 的第一次调用将对该值进行操作。

请注意，当mapFunction 被并发调用时，每次只有一个线程会调用reduceFunction 。调用reduceFunction 的顺序由reduceOptions 决定。

注意： 该函数将阻塞，直到序列中的所有项目都已处理完毕。

另请参阅 mapped() 以及并发 Map 和 Map-Reduce。

template <typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor, typename InitialValueType> ResultType QtConcurrent::blockingMappedReduced(QThreadPool **pool, Iterator begin, Iterator end, MapFunctor &&mapFunction, ReduceFunctor &&reduceFunction, InitialValueType &&initialValue, QtConcurrent::ReduceOptions reduceOptions* = ReduceOptions(UnorderedReduce | SequentialReduce))

从begin 到end ，每个项目调用一次mapFunction 。对mapFunction 的所有调用都是从QThreadPool pool 的线程中调用的。每个mapFunction 的返回值都会传递给reduceFunction 。在调用函数时，结果值被初始化为initialValue ，对reduceFunction 的第一次调用将对该值进行操作。

请注意，当mapFunction 被并发调用时，每次只有一个线程会调用reduceFunction 。调用reduceFunction 的顺序未定义。

注意： 此函数将阻塞，直到迭代器到达正在处理的序列的末尾。

另请参阅 blockingMappedReduced() 以及并发 Map 和 Map-Reduce。

template <typename Sequence, typename KeepFunctor> QFuture<void> QtConcurrent::filter(Sequence &sequence, KeepFunctor &&filterFunction)

对sequence 中的每个项目调用一次filterFunction 。如果filterFunction 返回true ，项目将保留在sequence 中；否则，项目将从sequence 中删除。

请注意，此方法没有处理迭代器的重载，因为它会使所操作序列的迭代器无效。

另请参阅 并发过滤器和过滤器-还原。

template <typename Sequence, typename KeepFunctor> QFuture<void> QtConcurrent::filter(QThreadPool **pool, Sequence &sequence, KeepFunctor &&filterFunction*)

请注意，此方法没有处理迭代器的重载，因为它会使所操作序列的迭代器失效。

另请参阅 并发过滤器和过滤器-还原。

template <typename Sequence, typename KeepFunctor> QFuture<typename std::decay_t<Sequence>::value_type> QtConcurrent::filtered(Sequence &&sequence, KeepFunctor &&filterFunction)

对sequence 中的每个项目调用一次filterFunction ，并返回一个新的保留项目序列。如果filterFunction 返回true ，项目的副本将被放入新序列。否则，该项目不会出现在新的序列中。

另请参阅 并发过滤和过滤-还原。

template <typename Iterator, typename KeepFunctor> QFuture<typename qValueType<Iterator>::value_type> QtConcurrent::filtered(Iterator begin, Iterator end, KeepFunctor &&filterFunction)

另请参阅 并发过滤和过滤-还原。

template <typename Sequence, typename KeepFunctor> QFuture<typename std::decay_t<Sequence>::value_type> QtConcurrent::filtered(QThreadPool **pool, Sequence &&sequence, KeepFunctor &&filterFunction*)

sequence 中的每个项目调用filterFunction 一次，并返回一个新的保留项目序列。对filterFunction 的所有调用都是从QThreadPool pool 的线程中调用的。如果filterFunction 返回true ，该项目副本将被放入新序列。否则，项目不会出现在新序列中。

另请参阅 并发过滤器和过滤器-还原。

template <typename Iterator, typename KeepFunctor> QFuture<typename qValueType<Iterator>::value_type> QtConcurrent::filtered(QThreadPool **pool, Iterator begin, Iterator end, KeepFunctor &&filterFunction*)

从begin 到end ，每个项目调用一次filterFunction ，并返回一个新的保留项目序列。对filterFunction 的所有调用都是从QThreadPool pool 的线程中调用的。如果filterFunction 返回true ，则该项目副本将放入新序列。否则，项目不会出现在新序列中。

另请参阅 并发过滤器和过滤器-还原。

template <typename ResultType, typename Sequence, typename KeepFunctor, typename ReduceFunctor> QFuture<ResultType> QtConcurrent::filteredReduced(Sequence &&sequence, KeepFunctor &&filterFunction, ReduceFunctor &&reduceFunction, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))

另请参阅 并发过滤和过滤-还原。

template <typename ResultType, typename Iterator, typename KeepFunctor, typename ReduceFunctor> QFuture<ResultType> QtConcurrent::filteredReduced(Iterator begin, Iterator end, KeepFunctor &&filterFunction, ReduceFunctor &&reduceFunction, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))

请注意，当filterFunction 被并发调用时，每次只有一个线程会调用reduceFunction 。如果reduceOptions 是QtConcurrent::UnorderedReduce ，则调用reduceFunction 的顺序是未定义的。如果reduceOptions 是QtConcurrent::OrderedReduce ，则调用reduceFunction 的顺序是原始序列的顺序。

另请参阅 并发过滤和过滤-还原。

template <typename ResultType, typename Sequence, typename KeepFunctor, typename ReduceFunctor> QFuture<ResultType> QtConcurrent::filteredReduced(QThreadPool **pool, Sequence &&sequence, KeepFunctor &&filterFunction, ReduceFunctor &&reduceFunction, QtConcurrent::ReduceOptions reduceOptions* = ReduceOptions(UnorderedReduce | SequentialReduce))

另请参阅 并发过滤和过滤-还原。

template <typename ResultType, typename Sequence, typename KeepFunctor, typename ReduceFunctor, typename InitialValueType> QFuture<ResultType> QtConcurrent::filteredReduced(Sequence &&sequence, KeepFunctor &&filterFunction, ReduceFunctor &&reduceFunction, InitialValueType &&initialValue, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))

请注意，在并发调用filterFunction 时，每次只有一个线程调用reduceFunction 。如果reduceOptions 是QtConcurrent::UnorderedReduce ，则调用reduceFunction 的顺序未定义。如果reduceOptions 是QtConcurrent::OrderedReduce ，则reduceFunction 将按照原始序列的顺序被调用。

另请参阅 并发过滤和过滤-还原。

template <typename ResultType, typename Iterator, typename KeepFunctor, typename ReduceFunctor, typename InitialValueType> QFuture<ResultType> QtConcurrent::filteredReduced(Iterator begin, Iterator end, KeepFunctor &&filterFunction, ReduceFunctor &&reduceFunction, InitialValueType &&initialValue, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))

另请参阅 并发过滤和过滤-还原。

template <typename ResultType, typename Iterator, typename KeepFunctor, typename ReduceFunctor> QFuture<ResultType> QtConcurrent::filteredReduced(QThreadPool **pool, Iterator begin, Iterator end, KeepFunctor &&filterFunction, ReduceFunctor &&reduceFunction, QtConcurrent::ReduceOptions reduceOptions* = ReduceOptions(UnorderedReduce | SequentialReduce))

另请参阅 并发过滤和过滤-还原。

template <typename ResultType, typename Sequence, typename KeepFunctor, typename ReduceFunctor, typename InitialValueType> QFuture<ResultType> QtConcurrent::filteredReduced(QThreadPool **pool, Sequence &&sequence, KeepFunctor &&filterFunction, ReduceFunctor &&reduceFunction, InitialValueType &&initialValue, QtConcurrent::ReduceOptions reduceOptions* = ReduceOptions(UnorderedReduce | SequentialReduce))

请注意，在并发调用filterFunction 时，每次只有一个线程调用reduceFunction 。如果reduceOptions 是QtConcurrent::UnorderedReduce ，则调用reduceFunction 的顺序未定义。如果reduceOptions 是QtConcurrent::OrderedReduce ，则reduceFunction 将按照原始序列的顺序被调用。

另请参阅 并发过滤和过滤-还原。

template <typename ResultType, typename Iterator, typename KeepFunctor, typename ReduceFunctor, typename InitialValueType> QFuture<ResultType> QtConcurrent::filteredReduced(QThreadPool **pool, Iterator begin, Iterator end, KeepFunctor &&filterFunction, ReduceFunctor &&reduceFunction, InitialValueType &&initialValue, QtConcurrent::ReduceOptions reduceOptions* = ReduceOptions(UnorderedReduce | SequentialReduce))

请注意，在并发调用filterFunction 时，每次只有一个线程调用reduceFunction 。如果reduceOptions 是QtConcurrent::UnorderedReduce ，则调用reduceFunction 的顺序是未定义的。如果reduceOptions 是QtConcurrent::OrderedReduce ，则调用reduceFunction 的顺序是原始序列的顺序。

另请参阅 并发过滤和过滤-还原。

template <typename Sequence, typename MapFunctor> QFuture<void> QtConcurrent::map(Sequence &&sequence, MapFunctor &&function)

sequence 中的每个项目调用一次function 。function 获取项目的引用，因此对项目所做的任何修改都会出现在sequence 中。

另请参阅 并发 Map 和 Map-Reduce。

template <typename Iterator, typename MapFunctor> QFuture<void> QtConcurrent::map(Iterator begin, Iterator end, MapFunctor &&function)

从begin 到end 的每个项目调用一次function 。function 获取项目的引用，因此对项目所做的任何修改都将出现在迭代器所属的序列中。

另请参阅 并发 Map 和 Map-Reduce。

template <typename Sequence, typename MapFunctor> QFuture<void> QtConcurrent::map(QThreadPool **pool, Sequence &&sequence, MapFunctor &&function*)

sequence 中的每个项目调用function 一次。对function 的所有调用都是从QThreadPool pool 的线程中调用的。function 获取项目的引用，因此对项目所做的任何修改都会出现在sequence 中。

另请参阅 并发 Map 和 Map-Reduce。

template <typename Iterator, typename MapFunctor> QFuture<void> QtConcurrent::map(QThreadPool **pool, Iterator begin, Iterator end, MapFunctor &&function*)

另请参阅 并发 Map 和 Map-Reduce。

template <typename Sequence, typename MapFunctor> QFuture<QtPrivate::MapResultType<Sequence, MapFunctor>> QtConcurrent::mapped(Sequence &&sequence, MapFunctor &&function)

对sequence 中的每个项目调用一次function ，并返回一个包含每个映射项目的 future 作为结果。您可以使用QFuture::const_iterator 或QFutureIterator 遍历结果。

另请参阅 并发映射和 Map-Reduce。

template <typename Iterator, typename MapFunctor> QFuture<QtPrivate::MapResultType<Iterator, MapFunctor>> QtConcurrent::mapped(Iterator begin, Iterator end, MapFunctor &&function)

从begin 到end 的每个项目调用一次function ，并返回一个包含每个映射项目的未来作为结果。您可以使用QFuture::const_iterator 或QFutureIterator 遍历结果。

另请参阅 并发映射和 Map-Reduce。

template <typename Sequence, typename MapFunctor> QFuture<QtPrivate::MapResultType<Sequence, MapFunctor>> QtConcurrent::mapped(QThreadPool **pool, Sequence &&sequence, MapFunctor &&function*)

sequence 中的每个项目调用一次function ，并返回一个包含每个映射项目的未来。对function 的所有调用都是从QThreadPool pool 的线程中调用的。您可以使用QFuture::const_iterator 或QFutureIterator 遍历结果。

另请参阅 并发映射和 Map-Reduce。

template <typename Iterator, typename MapFunctor> QFuture<QtPrivate::MapResultType<Iterator, MapFunctor>> QtConcurrent::mapped(QThreadPool **pool, Iterator begin, Iterator end, MapFunctor &&function*)

从begin 到end 的每个项目调用一次function ，并返回一个包含每个映射项目的未来。对function 的所有调用都是从QThreadPool pool 的线程中调用的。您可以使用QFuture::const_iterator 或QFutureIterator 遍历结果。

另请参阅 并发映射和 Map-Reduce。

template <typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor> QFuture<ResultType> QtConcurrent::mappedReduced(Sequence &&sequence, MapFunctor &&mapFunction, ReduceFunctor &&reduceFunction, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))

sequence 中的每个项目调用mapFunction 一次。每个mapFunction 的返回值都会传递给reduceFunction 。

请注意，虽然mapFunction 被并发调用，但每次只有一个线程调用reduceFunction 。调用reduceFunction 的顺序由reduceOptions 决定。

另请参阅 并发 Map 和 Map-Reduce。

template <typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor> QFuture<ResultType> QtConcurrent::mappedReduced(Iterator begin, Iterator end, MapFunctor &&mapFunction, ReduceFunctor &&reduceFunction, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))

从begin 到end ，每个项目都会调用一次mapFunction 。每次mapFunction 的返回值都会传递给reduceFunction 。

请注意，当mapFunction 被并发调用时，每次只有一个线程会调用reduceFunction 。默认情况下，调用reduceFunction 的顺序未定义。

注意： QtConcurrent::OrderedReduce 的结果是有序还原。

另请参阅 并发 Map 和 Map-Reduce。

template <typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor> QFuture<ResultType> QtConcurrent::mappedReduced(QThreadPool **pool, Sequence &&sequence, MapFunctor &&mapFunction, ReduceFunctor &&reduceFunction, QtConcurrent::ReduceOptions reduceOptions* = ReduceOptions(UnorderedReduce | SequentialReduce))

请注意，虽然mapFunction 会被并发调用，但每次只有一个线程会调用reduceFunction 。调用reduceFunction 的顺序由reduceOptions 决定。

另请参阅 并发 Map 和 Map-Reduce。

template <typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor, typename InitialValueType> QFuture<ResultType> QtConcurrent::mappedReduced(Sequence &&sequence, MapFunctor &&mapFunction, ReduceFunctor &&reduceFunction, InitialValueType &&initialValue, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))

请注意，在并发调用mapFunction 时，每次只有一个线程调用reduceFunction 。调用reduceFunction 的顺序由reduceOptions 决定。

另请参阅 并发 Map 和 Map-Reduce。

template <typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor, typename InitialValueType> QFuture<ResultType> QtConcurrent::mappedReduced(Iterator begin, Iterator end, MapFunctor &&mapFunction, ReduceFunctor &&reduceFunction, InitialValueType &&initialValue, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))

请注意，当mapFunction 被并发调用时，每次只有一个线程会调用reduceFunction 。默认情况下，调用reduceFunction 的顺序未定义。

注意： QtConcurrent::OrderedReduce 的结果是有序还原。

另请参阅 并发 Map 和 Map-Reduce。

template <typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor> QFuture<ResultType> QtConcurrent::mappedReduced(QThreadPool **pool, Iterator begin, Iterator end, MapFunctor &&mapFunction, ReduceFunctor &&reduceFunction, QtConcurrent::ReduceOptions reduceOptions* = ReduceOptions(UnorderedReduce | SequentialReduce))

请注意，当mapFunction 被并发调用时，每次只有一个线程会调用reduceFunction 。默认情况下，调用reduceFunction 的顺序未定义。

注意： QtConcurrent::OrderedReduce 的结果是有序缩减。

另请参阅 并发 Map 和 Map-Reduce。

template <typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor, typename InitialValueType> QFuture<ResultType> QtConcurrent::mappedReduced(QThreadPool **pool, Sequence &&sequence, MapFunctor &&mapFunction, ReduceFunctor &&reduceFunction, InitialValueType &&initialValue, QtConcurrent::ReduceOptions reduceOptions* = ReduceOptions(UnorderedReduce | SequentialReduce))

请注意，当mapFunction 被并发调用时，每次只有一个线程会调用reduceFunction 。调用reduceFunction 的顺序由reduceOptions 决定。

另请参阅 并发 Map 和 Map-Reduce。

template <typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor, typename InitialValueType> QFuture<ResultType> QtConcurrent::mappedReduced(QThreadPool **pool, Iterator begin, Iterator end, MapFunctor &&mapFunction, ReduceFunctor &&reduceFunction, InitialValueType &&initialValue, QtConcurrent::ReduceOptions reduceOptions* = ReduceOptions(UnorderedReduce | SequentialReduce))

请注意，当mapFunction 被并发调用时，每次只有一个线程会调用reduceFunction 。默认情况下，调用reduceFunction 的顺序未定义。

注意： QtConcurrent::OrderedReduce 的结果是有序还原。

另请参阅 并发 Map 和 Map-Reduce。

template <typename T> QFuture<T> QtConcurrent::run(Function function, ...)

相当于

QtConcurrent::run(QThreadPool::globalInstance(), function, ...);

在单独的线程中运行function 。线程取自全局QThreadPool 。请注意，function 可能不会立即运行；function 只有在线程可用时才会运行。

在基本模式下，T 与function 的返回值类型相同。非虚返回值可通过QFuture::result() 函数访问。

在基本模式下，返回的QFuture 只能用于查询函数的运行/完成状态和返回值。特别是，只有在未来的计算尚未开始时，才能取消或暂停。

在带承诺运行模式下，function 将返回 void，并且必须接受一个QPromise<T> & 类型的额外参数，作为第一个参数放在函数参数列表中。T 是结果类型，与返回的QFuture<T> 相同。

在带承诺运行模式下，与基本模式类似，返回的QFuture 可用于查询函数的运行/完成状态和报告值。此外，它还可用于暂停或取消正在运行的任务，从被调用的function 获取多个结果，或监控function 报告的进度。

另请参阅 并发运行（基本模式）、带承诺的并发运行和QThreadPool::start() 。

template <typename T> QFuture<T> QtConcurrent::run(QThreadPool **pool, Function function*, ...)

在pool 上调度function 。请注意，function 可能不会立即运行；function 只有在线程可用时才会运行。

在基本模式下，T 与function 的返回值类型相同。非虚返回值可通过QFuture::result() 函数访问。

在基本模式下，返回的QFuture 只能用于查询函数的运行/完成状态和返回值。特别是，只有在未来的计算尚未开始时，才能取消或暂停。

另请参阅 并发运行（基本模式）、带承诺的并发运行和QThreadPool::start() 。

`[since 6.0]` template <typename Task> QtConcurrent::QTaskBuilder<Task> QtConcurrent::task(Task &&task)

创建QtConcurrent::QTaskBuilder 的实例。该对象可用于调整某些参数，并在单独的线程中运行task 。

此函数在 Qt 6.0 中引入。

另请参阅 并发任务（Concurrent Task）和QtConcurrent::QTaskBuilder 。

© 2025 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.

QtConcurrent Namespace

类

类型

函数

详细说明

类

类QTaskBuilder

类型文档

enum class QtConcurrent::FutureResult

[alias] InvokeResultType

枚举 QtConcurrent::ReduceOptionflags QtConcurrent::ReduceOptions

函数文档

template <typename Sequence, typename KeepFunctor> void QtConcurrent::blockingFilter(Sequence &sequence, KeepFunctor &&filterFunction)

template <typename Sequence, typename KeepFunctor> void QtConcurrent::blockingFilter(QThreadPool *pool, Sequence &sequence, KeepFunctor &&filterFunction)

template <typename Sequence, typename KeepFunctor> std::decay_t<Sequence> QtConcurrent::blockingFiltered(Sequence &&sequence, KeepFunctor &&filterFunction)

template <typename OutputSequence, typename Iterator, typename KeepFunctor> OutputSequence QtConcurrent::blockingFiltered(Iterator begin, Iterator end, KeepFunctor &&filterFunction)

template <typename Sequence, typename KeepFunctor> std::decay_t<Sequence> QtConcurrent::blockingFiltered(QThreadPool *pool, Sequence &&sequence, KeepFunctor &&filterFunction)

template <typename OutputSequence, typename Iterator, typename KeepFunctor> OutputSequence QtConcurrent::blockingFiltered(QThreadPool *pool, Iterator begin, Iterator end, KeepFunctor &&filterFunction)

template <typename Sequence, typename MapFunctor> void QtConcurrent::blockingMap(Sequence &&sequence, MapFunctor &&function)

template <typename Iterator, typename MapFunctor> void QtConcurrent::blockingMap(Iterator begin, Iterator end, MapFunctor &&function)

template <typename Sequence, typename MapFunctor> void QtConcurrent::blockingMap(QThreadPool *pool, Sequence &&sequence, MapFunctor function)

template <typename Iterator, typename MapFunctor> void QtConcurrent::blockingMap(QThreadPool *pool, Iterator begin, Iterator end, MapFunctor &&function)

template <typename OutputSequence, typename InputSequence, typename MapFunctor> OutputSequence QtConcurrent::blockingMapped(InputSequence &&sequence, MapFunctor &&function)

template <typename Sequence, typename Iterator, typename MapFunctor> Sequence QtConcurrent::blockingMapped(Iterator begin, Iterator end, MapFunctor &&function)

template <typename OutputSequence, typename InputSequence, typename MapFunctor> OutputSequence QtConcurrent::blockingMapped(QThreadPool *pool, InputSequence &&sequence, MapFunctor &&function)

template <typename Sequence, typename Iterator, typename MapFunctor> Sequence QtConcurrent::blockingMapped(QThreadPool *pool, Iterator begin, Iterator end, MapFunctor &&function)

template <typename Sequence, typename KeepFunctor> QFuture<void> QtConcurrent::filter(Sequence &sequence, KeepFunctor &&filterFunction)

template <typename Sequence, typename KeepFunctor> QFuture<void> QtConcurrent::filter(QThreadPool *pool, Sequence &sequence, KeepFunctor &&filterFunction)

template <typename Sequence, typename KeepFunctor> QFuture<typename std::decay_t<Sequence>::value_type> QtConcurrent::filtered(Sequence &&sequence, KeepFunctor &&filterFunction)

template <typename Iterator, typename KeepFunctor> QFuture<typename qValueType<Iterator>::value_type> QtConcurrent::filtered(Iterator begin, Iterator end, KeepFunctor &&filterFunction)

template <typename Sequence, typename KeepFunctor> QFuture<typename std::decay_t<Sequence>::value_type> QtConcurrent::filtered(QThreadPool *pool, Sequence &&sequence, KeepFunctor &&filterFunction)

template <typename Iterator, typename KeepFunctor> QFuture<typename qValueType<Iterator>::value_type> QtConcurrent::filtered(QThreadPool *pool, Iterator begin, Iterator end, KeepFunctor &&filterFunction)

template <typename Sequence, typename MapFunctor> QFuture<void> QtConcurrent::map(Sequence &&sequence, MapFunctor &&function)

template <typename Iterator, typename MapFunctor> QFuture<void> QtConcurrent::map(Iterator begin, Iterator end, MapFunctor &&function)

template <typename Sequence, typename MapFunctor> QFuture<void> QtConcurrent::map(QThreadPool *pool, Sequence &&sequence, MapFunctor &&function)

template <typename Iterator, typename MapFunctor> QFuture<void> QtConcurrent::map(QThreadPool *pool, Iterator begin, Iterator end, MapFunctor &&function)

template <typename Sequence, typename MapFunctor> QFuture<QtPrivate::MapResultType<Sequence, MapFunctor>> QtConcurrent::mapped(Sequence &&sequence, MapFunctor &&function)

template <typename Iterator, typename MapFunctor> QFuture<QtPrivate::MapResultType<Iterator, MapFunctor>> QtConcurrent::mapped(Iterator begin, Iterator end, MapFunctor &&function)

template <typename Sequence, typename MapFunctor> QFuture<QtPrivate::MapResultType<Sequence, MapFunctor>> QtConcurrent::mapped(QThreadPool *pool, Sequence &&sequence, MapFunctor &&function)

template <typename Iterator, typename MapFunctor> QFuture<QtPrivate::MapResultType<Iterator, MapFunctor>> QtConcurrent::mapped(QThreadPool *pool, Iterator begin, Iterator end, MapFunctor &&function)

template <typename T> QFuture<T> QtConcurrent::run(Function function, ...)

template <typename T> QFuture<T> QtConcurrent::run(QThreadPool *pool, Function function, ...)

[since 6.0] template <typename Task> QtConcurrent::QTaskBuilder<Task> QtConcurrent::task(Task &&task)

`[alias]` InvokeResultType

枚举 QtConcurrent::ReduceOption
flags QtConcurrent::ReduceOptions

template <typename Sequence, typename KeepFunctor> void QtConcurrent::blockingFilter(QThreadPool **pool, Sequence &sequence, KeepFunctor &&filterFunction*)

template <typename Sequence, typename KeepFunctor> std::decay_t<Sequence> QtConcurrent::blockingFiltered(QThreadPool **pool, Sequence &&sequence, KeepFunctor &&filterFunction*)

template <typename OutputSequence, typename Iterator, typename KeepFunctor> OutputSequence QtConcurrent::blockingFiltered(QThreadPool **pool, Iterator begin, Iterator end, KeepFunctor &&filterFunction*)

template <typename Sequence, typename MapFunctor> void QtConcurrent::blockingMap(QThreadPool **pool, Sequence &&sequence, MapFunctor function*)

template <typename Iterator, typename MapFunctor> void QtConcurrent::blockingMap(QThreadPool **pool, Iterator begin, Iterator end, MapFunctor &&function*)

template <typename OutputSequence, typename InputSequence, typename MapFunctor> OutputSequence QtConcurrent::blockingMapped(QThreadPool **pool, InputSequence &&sequence, MapFunctor &&function*)

template <typename Sequence, typename Iterator, typename MapFunctor> Sequence QtConcurrent::blockingMapped(QThreadPool **pool, Iterator begin, Iterator end, MapFunctor &&function*)

template <typename Sequence, typename KeepFunctor> QFuture<void> QtConcurrent::filter(QThreadPool **pool, Sequence &sequence, KeepFunctor &&filterFunction*)

template <typename Sequence, typename KeepFunctor> QFuture<typename std::decay_t<Sequence>::value_type> QtConcurrent::filtered(QThreadPool **pool, Sequence &&sequence, KeepFunctor &&filterFunction*)

template <typename Iterator, typename KeepFunctor> QFuture<typename qValueType<Iterator>::value_type> QtConcurrent::filtered(QThreadPool **pool, Iterator begin, Iterator end, KeepFunctor &&filterFunction*)

template <typename Sequence, typename MapFunctor> QFuture<void> QtConcurrent::map(QThreadPool **pool, Sequence &&sequence, MapFunctor &&function*)

template <typename Iterator, typename MapFunctor> QFuture<void> QtConcurrent::map(QThreadPool **pool, Iterator begin, Iterator end, MapFunctor &&function*)

template <typename Sequence, typename MapFunctor> QFuture<QtPrivate::MapResultType<Sequence, MapFunctor>> QtConcurrent::mapped(QThreadPool **pool, Sequence &&sequence, MapFunctor &&function*)

template <typename Iterator, typename MapFunctor> QFuture<QtPrivate::MapResultType<Iterator, MapFunctor>> QtConcurrent::mapped(QThreadPool **pool, Iterator begin, Iterator end, MapFunctor &&function*)

template <typename T> QFuture<T> QtConcurrent::run(QThreadPool **pool, Function function*, ...)

`[since 6.0]` template <typename Task> QtConcurrent::QTaskBuilder<Task> QtConcurrent::task(Task &&task)