path: root/src/corelib
diff options
Diffstat (limited to 'src/corelib')
4 files changed, 6 insertions, 111 deletions
diff --git a/src/corelib/doc/src/threads.qdoc b/src/corelib/doc/src/threads.qdoc
index 27aca86406..1a31aa7815 100644
--- a/src/corelib/doc/src/threads.qdoc
+++ b/src/corelib/doc/src/threads.qdoc
@@ -63,7 +63,6 @@
\li \l{Synchronizing Threads}
\li \l{Reentrancy and Thread-Safety}
\li \l{Threads and QObjects}
- \li \l{Concurrent Programming}
\li \l{Thread-Support in Qt Modules}
@@ -449,7 +448,7 @@
\previouspage Reentrancy and Thread Safety
\contentspage Thread Support in Qt
- \nextpage Concurrent Programming
+ \nextpage Thread-Support in Qt Modules
QThread inherits QObject. It emits signals to indicate that the
thread started or finished executing, and provides a few slots as
@@ -646,113 +645,10 @@
- \page threads-qtconcurrent.html
- \title Concurrent Programming
- \previouspage Threads and QObjects
- \contentspage Thread Support in Qt
- \nextpage Thread-Support in Qt Modules
- \target qtconcurrent intro
- 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:
- \list
- \li QtConcurrent::map() applies a function to every item in a container,
- modifying the items in-place.
- \li QtConcurrent::mapped() is like map(), except that it returns a new
- container with the modifications.
- \li QtConcurrent::mappedReduced() is like mapped(), except that the
- modified results are reduced or folded into a single result.
- \li QtConcurrent::filter() removes all items from a container based on the
- result of a filter function.
- \li QtConcurrent::filtered() is like filter(), except that it returns a new
- container with the filtered results.
- \li QtConcurrent::filteredReduced() is like filtered(), except that the
- filtered results are reduced or folded into a single result.
- \li QtConcurrent::run() runs a function in another thread.
- \li QFuture represents the result of an asynchronous computation.
- \li QFutureIterator allows iterating through results available via QFuture.
- \li QFutureWatcher allows monitoring a QFuture using signals-and-slots.
- \li QFutureSynchronizer is a convenience class that automatically
- synchronizes several QFutures.
- \endlist
- Qt Concurrent supports several STL-compatible container and iterator types,
- but works best with Qt containers that have random-access iterators, such as
- QList or QVector. The map and filter functions accept both containers and begin/end iterators.
- STL Iterator support overview:
- \table
- \header
- \li Iterator Type
- \li Example classes
- \li Support status
- \row
- \li Input Iterator
- \li
- \li Not Supported
- \row
- \li Output Iterator
- \li
- \li Not Supported
- \row
- \li Forward Iterator
- \li std::slist
- \li Supported
- \row
- \li Bidirectional Iterator
- \li QLinkedList, std::list
- \li Supported
- \row
- \li Random Access Iterator
- \li QList, QVector, std::vector
- \li Supported and Recommended
- \endtable
- Random access iterators can be faster in cases where Qt Concurrent 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 Qt Concurrent
- to provide progress information trough QFuture::progressValue() and QFutureWatcher::
- progressValueChanged().
- The non in-place modifying functions such as mapped() and filtered() makes a
- copy of the container when called. If you are using STL containers this copy operation
- might take some time, in this case we recommend specifying the begin and end iterators
- for the container instead.
\page threads-modules.html
\title Thread-Support in Qt Modules
- \previouspage Concurrent Programming
+ \previouspage Threads and QObjects
\contentspage Thread Support in Qt
\section1 Threads and the SQL Module
diff --git a/src/corelib/thread/qfuture.qdoc b/src/corelib/thread/qfuture.qdoc
index 421e683c4a..7ae3e4a87e 100644
--- a/src/corelib/thread/qfuture.qdoc
+++ b/src/corelib/thread/qfuture.qdoc
@@ -47,8 +47,7 @@
\ingroup thread
- To start a computation, use one of the APIs in the
- \l {Concurrent Programming}{Qt Concurrent} framework.
+ To start a computation, use one of the APIs in the \l {Qt Concurrent} framework.
QFuture allows threads to be synchronized against one or more results
which will be ready at a later point in time. The result can be of any type
@@ -93,7 +92,7 @@
To interact with running tasks using signals and slots, use QFutureWatcher.
- \sa QFutureWatcher, {Concurrent Programming}{Qt Concurrent}
+ \sa QFutureWatcher, {Qt Concurrent}
/*! \fn QFuture::QFuture()
diff --git a/src/corelib/thread/qfuturesynchronizer.qdoc b/src/corelib/thread/qfuturesynchronizer.qdoc
index 7ad978f61d..cc31dff46d 100644
--- a/src/corelib/thread/qfuturesynchronizer.qdoc
+++ b/src/corelib/thread/qfuturesynchronizer.qdoc
@@ -66,7 +66,7 @@
You can query the status of the cancel-on-wait feature using the
cancelOnWait() function.
- \sa QFuture, QFutureWatcher, {Concurrent Programming}{Qt Concurrent}
+ \sa QFuture, QFutureWatcher, {Qt Concurrent}
diff --git a/src/corelib/thread/qfuturewatcher.cpp b/src/corelib/thread/qfuturewatcher.cpp
index 53a00a8212..a7f2dd9f73 100644
--- a/src/corelib/thread/qfuturewatcher.cpp
+++ b/src/corelib/thread/qfuturewatcher.cpp
@@ -98,7 +98,7 @@ QT_BEGIN_NAMESPACE
QFutureWatcher<void> as well. This is useful if only status or progress
information is needed; not the actual result data.
- \sa QFuture, {Concurrent Programming}{Qt Concurrent}
+ \sa QFuture, {Qt Concurrent}
/*! \fn QFutureWatcher::QFutureWatcher(QObject *parent)