Multithreading Technologies in Qt▲
<Unknown command>contentspageThread Support in Qt
Qt offers many classes and functions for working with threads. Below are four different approaches that Qt programmers can use to implement multithreaded applications.
QThread: Low-Level API with Optional Event Loops▲
https:// is the foundation of all thread control in Qt. Each https:// instance represents and controls one thread.
https:// can either be instantiated directly or subclassed. Instantiating a https:// provides a parallel event loop, allowing QObject slots to be invoked in a secondary thread. Subclassing a https:// allows the application to initialize the new thread before starting its event loop, or to run parallel code without an event loop.
See the https:// and the https:// for demonstrations on how to use https://.
QThreadPool and QRunnable: Reusing Threads▲
Creating and destroying threads frequently can be expensive. To reduce this overhead, existing threads can be reused for new tasks. QThreadPool is a collection of reuseable QThreads.
To run code in one of a QThreadPool's threads, reimplement QRunnable::run() and instantiate the subclassed QRunnable. Use QThreadPool::start() to put the QRunnable in the QThreadPool's run queue. When a thread becomes available, the code within QRunnable::run() will execute in that thread.
Each Qt application has a global thread pool, which is accessible through QThreadPool::globalInstance(). This global thread pool automatically maintains an optimal number of threads based on the number of cores in the CPU. However, a separate QThreadPool can be created and managed explicitly.
Qt Concurrent: Using a High-level API▲
The https:// module provides high-level functions that deal with some common parallel computation patterns: map, filter, and reduce. Unlike using https:// and QRunnable, these functions never require the use of https:// such as mutexes or semaphores. Instead, they return a https:// object which can be used to retrieve the functions' results when they are ready. https:// can also be used to query computation progress and to pause/resume/cancel the computation. For convenience, https:// enables interactions with https://s via signals and slots.
https://'s map, filter and reduce algorithms automatically distribute computation across all available processor cores, so applications written today will continue to scale when deployed later on a system with more cores.
This module also provides the https://() function, which can run any function in another thread. However, https://() only supports a subset of features available to the map, filter and reduce functions. The https:// can be used to retrieve the function's return value and to check if the thread is running. However, a call to https://() uses one thread only, cannot be paused/resumed/canceled, and cannot be queried for progress.
See the https:// module documentation for details on the individual functions.
WorkerScript: Threading in QML▲
The https:// QML type lets JavaScript code run in parallel with the GUI thread.
Each https:// instance can have one .js script attached to it. When https://() is called, the script will run in a separate thread (and a separate QML context). When the script finishes running, it can send a reply back to the GUI thread which will invoke the https://() signal handler.
Using a https:// is similar to using a worker QObject that has been moved to another thread. Data is transferred between threads via signals.
See the https:// documentation for details on how to implement the script, and for a list of data types that can be passed between threads.
Choosing an Appropriate Approach▲
As demonstrated above, Qt provides different solutions for developing threaded applications. The right solution for a given application depends on the purpose of the new thread and the thread's lifetime. Below is a comparison of Qt's threading technologies, followed by recommended solutions for some example use cases.
Comparison of Solutions▲
|
Feature |
https:// |
QRunnable and QThreadPool |
https://() |
Qt Concurrent (Map, Filter, Reduce) |
https:// |
|---|---|---|---|---|---|
|
Language |
C++ |
C++ |
C++ |
C++ |
QML |
|
Thread priority can be specified |
Yes |
Yes |
|||
|
Thread can run an event loop |
Yes |
||||
|
Thread can receive data updates through signals |
Yes (received by a worker QObject) |
Yes (received by https://) |
|||
|
Thread can be controlled using signals |
Yes (received by https://) |
Yes (received by https://) |
|||
|
Thread can be monitored through a https:// |
Partially |
Yes |
|||
|
Built-in ability to pause/resume/cancel |
Yes |
Example Use Cases▲
|
Lifetime of thread |
Operation |
Solution |
|---|---|---|
|
One call |
Run a new linear function within another thread, optionally with progress updates during the run. |
Qt provides different solutions:
|
|
One call |
Run an existing function within another thread and get its return value. |
Run the function using https://(). Have a https:// emit the finished() signal when the function has returned, and call QFutureWatcher::result() to get the function's return value. |
|
One call |
Perform an operation on all items of a container, using all available cores. For example, producing thumbnails from a list of images. |
Use Qt Concurrent's QtConcurrent::filter() function to select container elements, and the QtConcurrent::map() function to apply an operation to each element. To fold the output into a single result, use QtConcurrent::filteredReduced() and QtConcurrent::mappedReduced() instead. |
|
One call/Permanent |
Perfrom a long computation in a pure QML application, and update the GUI when the results are ready. |
Place the computation code in a .js script and attach it to a https:// instance. Call https://() to start the computation in a new thread. Let the script call sendMessage() too, to pass the result back to the GUI thread. Handle the result in onMessage and update the GUI there. |
|
Permanent |
Have an object living in another thread that can perform different tasks upon request and/or can receive new data to work with. |
Subclass a QObject to create a worker. Instantiate this worker object and a https://. Move the worker to the new thread. Send commands or data to the worker object over queued signal-slot connections. |
|
Permanent |
Repeatedly perform an expensive operation in another thread, where the thread does not need to receive any signals or events. |
Write the infinite loop directly within a reimplementation of QThread::run(). Start the thread without an event loop. Let the thread emit signals to send data back to the GUI thread. |
▲
| https:// | https:// |