Home > Articles > Programming > C/C++
- Qt Thread Slots And Signals Chart
- Qthread Signal Slot
- Qt Thread Slots And Signals Online
- Qt Thread Slots And Signals For Kids
- Qt Main Thread
- Qt Signal Slot Example
How Qt Signals and Slots Work - Part 3 - Queued and Inter Thread Connections This blog is part of a series of blogs explaining the internals of signals and slots. Part 1 - How Qt Signals and Slots Work.
␡- Creating Threads
This chapter is from the book
This chapter is from the book
14. Multithreading
- Creating Threads
- Synchronizing Threads
- Communicating with the Main Thread
- Using Qt's Classes in Secondary Threads
Conventional GUI applications have one thread of execution and perform one operation at a time. If the user invokes a time-consuming operation from the user interface, the interface typically freezes while the operation is in progress. Chapter 7 presents some solutions to this problem. Multithreading is another solution.
In a multithreaded application, the GUI runs in its own thread and additional processing takes place in one or more other threads. This results in applications that have responsive GUIs even during intensive processing. When runnning on a single processor, multithreaded applications may run slower than a single-threaded equivalent due to the overhead of having multiple threads. But on multiprocessor systems, which are becoming increasingly common, multithreaded applications can execute several threads simultaneously on different processors, resulting in better overall performance.
In this chapter, we will start by showing how to subclass QThread and how to use QMutex, QSemaphore, and QWaitCondition to synchronize threads. [*] Then we will see how to communicate with the main thread from secondary threads while the event loop is running. Finally, we round off with a review of which Qt classes can be used in secondary threads and which cannot.
Multithreading is a large topic with many books devoted to the subject—for example, Threads Primer: A Guide to Multithreaded Programming by Bil Lewis and Daniel J. Berg (Prentice Hall, 1995) and Multithreaded, Parallel, and Distributed Programming by Gregory Andrews (Addison-Wesley, 2000). Here it is assumed that you already understand the fundamentals of multithreaded programming, so the focus is on explaining how to develop multithreaded Qt applications rather than on the subject of threading itself.
Creating Threads
Providing multiple threads in a Qt application is straightforward: We just subclass QThread and reimplement its run() function. To show how this works, we will start by reviewing the code for a very simple QThread subclass that repeatedly prints a given string on a console. The application's user interface is shown in Figure 14.1.
Figure 14.1 The Threads application
The Thread class is derived from QThread and reimplements the run() function. It provides two additional functions: setMessage() and stop().
The stopped variable is declared volatile because it is accessed from different threads and we want to be sure that it is freshly read every time it is needed. If we omitted the volatile keyword, the compiler might optimize access to the variable, possibly leading to incorrect results.
We set stopped to false in the constructor.
The run() function is called to start executing the thread. As long as the stopped variable is false, the function keeps printing the given message to the console. The thread terminates when control leaves the run() function.
The stop() function sets the stopped variable to true, thereby telling run() to stop printing text to the console. This function can be called from any thread at any time. For the purposes of this example, we assume that assignment to a bool is an atomic operation. This is a reasonable assumption, considering that a bool can have only two states. We will see later in this section how to use QMutex to guarantee that assigning to a variable is an atomic operation.
QThread provides a terminate() function that terminates the execution of a thread while it is still running. Using terminate() is not recommended, since it can stop the thread at any point and does not give the thread any chance to clean up after itself. It is always safer to use a stopped variable and a stop() function as we did here.
We will now see how to use the Thread class in a small Qt application that uses two threads, A and B, in addition to the main thread.
The ThreadDialog class declares two variables of type Thread and some buttons to provide a basic user interface.
In the constructor, we call setMessage() to make the first thread repeatedly print 'A's and the second thread 'B's.
When the user clicks the button for thread A, startOrStopThreadA() stops the thread if it was running and starts it otherwise. It also updates the button's text.
The code for startOrStopThreadB() is structurally identical.
If the user clicks Quit or closes the window, we stop any running threads and wait for them to finish (using QThread::wait()) before we call QCloseEvent::accept(). This ensures that the application exits in a clean state, although it doesn't really matter in this example.
If you run the application and click Start A, the console will be filled with 'A's. If you click Start B, it will now fill with alternating sequences of 'A's and 'B's. Click Stop A, and now it will print only 'B's.
Related Resources
Qt Thread Slots And Signals Chart
- Book $31.99
- Book $35.99
- Book $43.99
Qt does not provide support for using the Signals & Slots mechanism in combination with C++ templates. See: https://doc.qt.io/qt-5/why-moc.html
However: It is actually possible to do this, when one is willing to keep track of the things normally handledby the QObject::connect() function and 'call' slots with QMetaObject::invokeMethod().
Doing this has some nice side effects like not having to call qRegisterMetaType() or using the Q_DECLARE_METATYPE macro.
For a more detailed explanation take a look at the documentation of the invokeInContext() function in Magic.h
Furthermore does Qt provide mechanisms for threading, as being described here: https://doc.qt.io/qt-5/threads-technologies.html#choosing-an-appropriate-approach
Qthread Signal Slot
The case 'Have an object living in another thread that can perform different tasks upon request and/or can receive new data to work with'
has the proposed solution 'Subclass a QObject to create a worker. Instantiate this worker object and a QThread. Move the worker to the new thread. Send commands or data to the worker object over queued signal-slot connections'
which implies not being able to use C++ templates, when relying solely on the native Signals & Slots mechanism.
But since I am lazy and don't like Copy & Paste, this framework provides a solution for handling that case in combination with C++ templates.
Qt Thread Slots And Signals Online
The main idea is to have 'Tasks' and 'Results', which are being described by template parameters 'T' and 'R' in this framework.
A Worker, which is running in his own thread, receives a task and responds with a result.
Qt Thread Slots And Signals For Kids
In general do you need to inherit from the Processor template class, the Worker template classand implement at least the pure virtual methods to create the functionality you want and give instances of thosenew classes to a Controller. That's it.
In order to be able to start working on new tasks, change the number of threads to use etc. you need a communication channelto the instance of the Processor.
You may use Qt Signals & Slots or use the invokeInContext() function Signals & Slots mechanism of this framework.The first example in src/examples/one/ covers all of that.
The second example in src/examples/two/ focuses only on the Signals & Slots system of this framework.
A third example in src/examples/three/ shows usage of the threading architecture + Signals and Slots of this frameworkcompletely without using Qt Signals and Slots.
Everything you need is documented in the CMakeLists.txt.
If you don't know what to do with such a file, you should use a search engine to find out.
Qt Main Thread
Use the Doxyfile to generate the documentation via Doxygen.
Qt Signal Slot Example
Look into the src/examples/ folder.