The QtConcurrent namespace provides high-level APIs that make it possible to write multi-threaded programs without using low-level threading primitives such as mutexes, read-write locks, wait conditions, or semaphores. Programs written with QtConcurrent automatically adjust the number of threads used according to the number of processor cores available. This means that applications written today will continue to scale when deployed on multi-core systems in the future.

QtConcurrent includes functional programming style APIs for parallel list processing, including a MapReduce and FilterReduce implementation for shared-memory (non-distributed) systems, and classes for managing asynchronous computations in GUI applications:

• QtConcurrent::map() applies a function to every item in a container, modifying the items in-place.
• QtConcurrent::mapped() is like map(), except that it returns a new container with the modifications.
• QtConcurrent::mappedReduced() is like mapped(), except that the modified results are reduced or folded into a single result.
• QtConcurrent::filter() removes all items from a container based on the result of a filter function.
• QtConcurrent::filtered() is like filter(), except that it returns a new container with the filtered results.
• QtConcurrent::filteredReduced() is like filtered(), except that the filtered results are reduced or folded into a single result.
• QtConcurrent::run() runs a function in another thread.
• QFuture represents the result of an asynchronous computation.
• QFutureIterator allows iterating through results available via QFuture.
• QFutureWatcher allows monitoring a QFuture using signals-and-slots.
• QFutureSynchronizer is a class which automatically synchronizes several QFutures.

QtConcurrent supports several container and iterator types, but works best with containers which have random access iterators like QList or QVector. The map and filter functions accept both containers and begin/end iterators.

Random access iterators can be faster in cases where QtConcurrent is iterating over a large number of lightweight items, since they allow skipping to any point in the container. In addition, using random access iterators allows QtConcurrent to provide progress information through QFuture::progressValue() and QFutureWatcher::progressValueChanged().

The non in-place modifying functions such as mapped() and filtered() make a copy of the container. This copy operation might be slow. It may be faster to specify the begin and end iterators for the container.