QtConcurrent Namespace

QtConcurrent 命名空间提供了高级 API，使开发者无需使用低级线程原语即可编写多线程程序。更多内容...

头文件：	`#include <QtConcurrent>`

CMake：	`find_package(Qt6 REQUIRED COMPONENTS Concurrent)` `target_link_libraries(mytarget PRIVATE Qt6::Concurrent)`
qmake：	`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 模块文档，了解可用函数的概述，或参阅下文了解每个函数的详细信息。

优化包含

如果包含<QtConcurrent> 头文件，则会同时包含整个Qt Concurrent 模块和整个Qt Core 模块，这可能会增加编译时间和二进制文件大小。若要使用QtConcurrent命名空间中的单个函数，可以包含更具体的头文件。

下表列出了 QtConcurrent 命名空间中的函数及其对应的头文件：

函数	头文件
QtConcurrent::run()	`<QtConcurrentRun>`
QtConcurrent::task()	`<QtConcurrentTask>`
QtConcurrent::filter(),QtConcurrent::filtered(),QtConcurrent::filteredReduced()	`<QtConcurrentFilter>`
QtConcurrent::map(),QtConcurrent::mapped(),QtConcurrent::mappedReduced()	`<QtConcurrentMap>`

类

类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>...>;

实际实现中还包含一项编译时检查，用于验证该任务是否可以使用指定的参数进行调用。

enum QtConcurrent::ReduceOption
flags QtConcurrent::ReduceOptions

此枚举指定了从 map 或 filter 函数返回的结果以何种顺序传递给 reduce 函数。

常量	值	描述
`QtConcurrent::UnorderedReduce`	`0x1`	按任意顺序进行归约。
`QtConcurrent::OrderedReduce`	`0x2`	按原始序列的顺序进行归约。
`QtConcurrent::SequentialReduce`	`0x4`	缩减按顺序进行：每次只有一个线程会进入 reduce 函数。（Qt Concurrent 的未来版本可能会支持并行缩减。）

ReduceOptions 类型是QFlags<ReduceOption> 的 typedef 定义。它存储 ReduceOption 值的“或”组合。

函数文档

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() 以及并行过滤（Concurrent Filter）和过滤-归约（Filter-Reduce）。

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 ，并返回一个包含保留项的新Sequence。所有对filterFunction 的调用均由从QThreadPool pool 中获取的线程执行。如果filterFunction 返回true ，则该项的副本将被放入新Sequence中。否则，该项不会出现在新Sequence中。

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

另请参阅 filtered() 以及并发过滤器和过滤-归约。

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

针对从 `begin ` 到 `end ` 的每个项，调用一次 `filterFunction `，并返回一个包含保留项的新 `Sequence`。所有对 `filterFunction ` 的调用均由从 `QThreadPool ` 获取的线程执行（详见pool ）。如果 `filterFunction ` 返回 `true`，则该项的副本将被放入新 `Sequence` 中；否则，该项不会出现在新 `Sequence` 中。

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

另请参阅 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 的结果。

请注意，虽然会并发调用filterFunction ，但每次只有一个线程会调用reduceFunction 。如果reduceOptions 为QtConcurrent::UnorderedReduce ，则reduceFunction 的调用顺序未定义。如果reduceOptions 为QtConcurrent::OrderedReduce ，则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 。换言之，返回值是针对每个项执行reduceFunction 所得的结果，其中filterFunction 返回true 。

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

另请参阅 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 。换句话说，返回值是reduceFunction 对于每个项的计算结果，其中filterFunction 返回true 。该函数被调用时，结果值会被初始化为initialValue ，而对reduceFunction 的首次调用将基于此值进行操作。

请注意，虽然filterFunction 会被并发调用，但每次只有一个线程会调用reduceFunction 。若reduceOptions 为QtConcurrent::UnorderedReduce ，则reduceFunction 的调用顺序未定义。若reduceOptions 为QtConcurrent::OrderedReduce ，则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))

针对sequence 中的每个项，调用一次filterFunction 。所有对filterFunction 的调用均由从QThreadPool pool 中获取的线程执行。如果filterFunction 针对某项返回true ，则该项将被传递给reduceFunction 。换言之，返回值是对于每个项执行reduceFunction 所得的结果，其中filterFunction 返回true 。当函数被调用时，结果值被初始化为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(QThreadPool **pool, Iterator begin, Iterator end, KeepFunctor &&filterFunction, ReduceFunctor &&reduceFunction, InitialValueType &&initialValue, QtConcurrent::ReduceOptions reduceOptions* = ReduceOptions(UnorderedReduce | SequentialReduce))

对于从begin 到end 之间的每个项目，都会调用一次filterFunction 。所有对filterFunction 的调用均由从QThreadPool pool 中获取的线程执行。如果filterFunction 对于某个项目返回true ，则该项目会被传递给reduceFunction 。换言之，返回值是对于每个项目的reduceFunction 的结果，其中filterFunction 会返回true 。当函数被调用时，结果值会被初始化为initialValue ，而对reduceFunction 的首次调用将操作此值。

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

另请参阅 filteredReduced() 以及并发过滤器和过滤-归约。

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

针对sequence 中的每个项目，调用一次function 。function 接受该项目的引用，因此对该项目所做的任何修改都会反映在sequence 中。

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

另请参阅 map() 以及“并发映射”和“映射-归约”。

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() 以及并发映射和映射-归约。

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-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() 以及并发映射和映射-归约。

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() 以及《并发映射》和《映射-归约》。

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() 以及《并发映射》和《映射-归约》。

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-Reduce。

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

针对sequence 中的每个元素，调用一次filterFunction 。如果filterFunction 返回true ，则该元素保留在sequence 中；否则，该元素将从sequence 中移除。

请注意，该方法没有支持迭代器的重载版本，因为它会使所操作序列的迭代器失效。

另请参阅 并发过滤器（Concurrent Filter）和过滤-缩减（Filter-Reduce）。

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

针对sequence 中的每个元素，调用一次filterFunction 。所有对filterFunction 的调用均由从QThreadPool pool 中获取的线程发起。如果filterFunction 返回true ，则该元素保留在sequence 中；否则，该元素将从sequence 中移除。

请注意，该方法没有支持迭代器的重载版本，因为它会使所操作序列的迭代器失效。

另请参阅 并发过滤器（Concurrent Filter）和过滤-缩减（Filter-Reduce）。

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

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

另请参阅 “并发过滤器”和“过滤-缩减”。

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

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

另请参阅 并发过滤器和过滤-缩减。

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

针对sequence 中的每个项，调用一次filterFunction ，并返回一个包含保留项的新Sequence。所有对filterFunction 的调用均由从QThreadPool pool 中获取的线程执行。如果filterFunction 返回true ，则该项的副本将被放入新的Sequence中。否则，该项不会出现在新的Sequence中。

另请参阅 并发过滤器和过滤-缩减。

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`，则该项目的副本将被放入新序列中；否则，该项目将不会出现在新序列中。

另请参阅 并发过滤器（Concurrent Filter）和过滤-归约（Filter-Reduce）。

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

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

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

另请参阅 “并发过滤器”和“过滤器-缩减”。

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

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

另请参阅 并发过滤器和过滤-缩减。

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

针对sequence 中的每个项，调用一次filterFunction 。所有对filterFunction 的调用均由从QThreadPool pool 中获取的线程执行。如果filterFunction 对某个项返回true ，则该项会被传递给reduceFunction 。换言之，返回值是reduceFunction 对每个项的计算结果，其中filterFunction 返回true 。

另请参阅 并发过滤器和过滤-缩减。

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

对于sequence 中的每个项，都会调用一次filterFunction 。如果filterFunction 对某项返回true ，则该项会被传递给reduceFunction 。换句话说，返回值是对于所有满足filterFunction 返回true 的项，其reduceFunction 计算结果的集合。当函数被调用时，结果值会被初始化为initialValue ，而对reduceFunction 的首次调用将基于此值进行操作。

请注意，虽然会并发调用 `filterFunction `，但每次仅有一个线程会调用 `reduceFunction`。如果 `reduceOptions ` 为 `QtConcurrent::UnorderedReduce`，则 `reduceFunction ` 的调用顺序未定义。如果 `reduceOptions ` 为 `QtConcurrent::OrderedReduce`，则 `reduceFunction ` 将按原始序列的顺序被调用。

另请参阅 并发过滤器（Concurrent Filter）和过滤-缩减（Filter-Reduce）。

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

对于从begin 到end 之间的每个项，都会调用一次filterFunction 。如果filterFunction 对于某一项返回true ，则该项会被传递给reduceFunction 。换句话说，返回值是对于每个满足filterFunction 返回true 的项，执行reduceFunction 所得的结果。当函数被调用时，结果值会被初始化为initialValue ，而对reduceFunction 的首次调用将对该值进行操作。

另请参阅 并发过滤器（Concurrent Filter）和过滤器-缩减（Filter-Reduce）。

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

对于从begin 到end 的每个项目，都会调用一次filterFunction 。所有对filterFunction 的调用均由从QThreadPool pool 获取的线程执行。如果filterFunction 针对某个项目返回true ，则该项目会被传递给reduceFunction 。换言之，返回值是针对每个项目的reduceFunction 的结果，其中filterFunction 返回true 。

请注意，虽然filterFunction 会被并发调用，但每次仅有一个线程会调用reduceFunction 。若reduceOptions 的值是QtConcurrent::UnorderedReduce ，则reduceFunction 的调用顺序未定义。若reduceOptions 的值为QtConcurrent::OrderedReduce ，则reduceFunction 将按原始序列的顺序被调用。

另请参阅 并发过滤器（Concurrent Filter）和过滤-归约（Filter-Reduce）。

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

针对sequence 中的每个项，调用一次filterFunction 。所有对filterFunction 的调用均由从QThreadPool pool 中获取的线程发起。如果filterFunction 对某项返回true ，则该项将被传递给reduceFunction 。换言之，返回值是对于每个项执行reduceFunction 所得的结果，其中filterFunction 返回true 。当函数被调用时，结果值被初始化为initialValue ，而对reduceFunction 的首次调用将基于此值进行操作。

另请参阅 并发过滤器（Concurrent Filter）和过滤-缩减（Filter-Reduce）。

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

对于从begin 到end 之间的每个项目，都会调用一次filterFunction 。所有对filterFunction 的调用均由从QThreadPool pool 中获取的线程执行。如果filterFunction 对于某个项目返回true ，则该项目会被传递给reduceFunction 。换言之，返回值是对于每个项目的reduceFunction 的结果，其中filterFunction 返回true 。当函数被调用时，结果值会被初始化为initialValue ，而首次调用reduceFunction 时将操作此值。

请注意，虽然会并发调用filterFunction ，但每次仅有一个线程会调用reduceFunction 。若reduceOptions 为QtConcurrent::UnorderedReduce ，则reduceFunction 的调用顺序未定义。若reduceOptions 为QtConcurrent::OrderedReduce ，则reduceFunction 将按原始序列的顺序被调用。

另请参阅 并发过滤器（Concurrent Filter）和过滤-归约（Filter-Reduce）。

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

针对sequence 中的每个项目，调用一次function 。function 接受该项目的引用，因此对该项目所做的任何修改都会反映在sequence 中。

另请参阅 并发映射和映射-归约。

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

针对从begin 到end 之间的每个项目，调用一次function 。function 接受该项目的引用，因此对该项目所做的任何修改都会反映在迭代器所属的序列中。

另请参阅 “并发映射”和“映射-归约”。

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

针对sequence 中的每个项，调用一次function 。所有对function 的调用均由从QThreadPool pool 中获取的线程执行。function 会获取该项的引用，因此对该项所做的任何修改都会反映在sequence 中。

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

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

对于从 `begin ` 到 `end` 之间的每个项，都会调用一次 `function `。所有对 `function ` 的调用均由从 `QThreadPool `（pool ）中获取的线程执行。`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 遍历这些结果。

另请参阅 “并发映射”和“映射-归约”。

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 ` 遍历这些结果。

另请参阅 “并发映射”和“映射-归约”。

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

针对sequence 中的每个元素，调用一次function ，并返回一个Future，其中每个映射后的元素作为结果。所有对function 的调用均由从QThreadPool pool 中获取的线程执行。您可以使用QFuture::const_iterator 或QFutureIterator 来遍历结果。

另请参阅 “并发 Map”和“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 ，并返回一个 Future，其中每个映射后的项目作为结果。所有对function 的调用均由从QThreadPool pool 获取的线程执行。您可以使用QFuture::const_iterator 或QFutureIterator 遍历结果。

另请参阅 并发映射和映射-归约。

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 决定。

另请参阅 “并发映射”和“映射-归约”。

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

针对sequence 中的每个项，调用一次mapFunction 。所有对mapFunction 的调用均由从QThreadPool 中获取的线程执行pool 。每个mapFunction 的返回值会被传递给reduceFunction 。

请注意，虽然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))

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

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

另请参阅 “并发映射”和“映射-归约”。

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

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

请注意，虽然会并发调用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))

对于begin 到end 之间的每个项目，都会调用一次mapFunction 。所有对mapFunction 的调用均由从QThreadPool pool 中获取的线程执行。每个mapFunction 的返回值都会传递给reduceFunction 。

请注意，虽然会并发调用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))

针对 `sequence` 中的每个项目，调用一次 `mapFunction `。所有对 `mapFunction ` 的调用均由从 `QThreadPool `pool 中获取的线程发起。每个 `mapFunction ` 的返回值都会传递给 `reduceFunction`。当函数被调用时，结果值会被初始化为 `initialValue `，而对 `reduceFunction ` 的首次调用将基于此值进行操作。

请注意，虽然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))

针对从begin 到end 之间的每个项目，分别调用一次mapFunction 。所有对mapFunction 的调用均由从QThreadPool pool 中获取的线程发起。每次mapFunction 的返回值都会传递给reduceFunction 。当该函数被调用时，结果值会被初始化为initialValue ，而对reduceFunction 的首次调用将基于该值进行操作。

请注意，虽然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` 的返回值类型相同。非 void 类型的返回值可通过 `QFuture::result()` 函数获取。

在基本模式下，返回的QFuture 仅可用于查询运行/完成状态以及该函数的返回值。特别地，只有在未来背后的计算尚未开始时，才能发出取消或暂停指令。

在“基于 Promise 运行”模式下，function 应返回 void，并且必须接受一个额外参数，该参数的类型为QPromise<T> & ，并作为函数参数列表中的第一个参数。T 是结果类型，与返回的QFuture<T> 相同。

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

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

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

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

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

在基本模式下，返回的QFuture 仅可用于查询运行/完成状态以及该函数的返回值。特别地，只有在未来对象背后的计算尚未开始时，才能执行取消或暂停操作。

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

另请参阅 “并发运行（基本模式）”、“带 Promise 的并发运行”以及“QThreadPool::start()”。

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

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

该函数在 Qt 6.0 中引入。

另请参阅 “并发任务”和“QtConcurrent::QTaskBuilder ”。

© 2026 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

enum 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

enum 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)