• Qt Signal Slot Class
• Qt Signal Slot Same Classic
• Qt Signal Slot Performance
• Qt Signal Slot Example
• Qt Signal Slot Same Classifieds
• Qt Signal Slot Thread

Signals and slots were one of the distinguishing features that made Qt an exciting and innovative tool back in time. But sometimes you can teach new tricks to an old dog, and QObjects gained a new way to connect between signals and slots in Qt5, plus some extra features to connect to other functions which are not slots. Let’s review how to get the most of that feature. This assumes you are already moderately familiar with signals and slots.

Background:I defined a QT parent class, which has a custom signal and slot function. I defined the parent class pointer in the main function to point to the subclass object. At this time, I sent a signal, and the subclass could not receive it. We started our exploration Solution:According to the breakpoint, it is found that the signal of the.

• One of the features which I have been working on is a new syntax for signals and slot. This blog entry will present it. The type names of the slot must match exactly the ones of the signal. And they also need to be the same in the header and in the connect statement. The slot was just declared as public and not as slot.
• Qt 5 continues to support the old string-based syntax for connecting signals and slots defined in a QObject or any class that inherits from QObject (including QWidget) connect (sender, SIGNAL (valueChanged (QString, QString)), receiver, SLOT (updateValue (QString))); New: connecting to QObject.

One simple thought about the basics

I am not going to bore you with repeating basic knowledge you already have, but I want you to look at signals and slots from a certain angle, so it will be easier to understand the design of the feature I will cover next. What’s the purpose of signals and slots? It’s a way in which “one object” makes sure that when “something happened”, then “other object” “reacts to something happened”. As simple as that. That can be expressed in pseudocode like this:

Notice that the four phrases that are into quotes in the previous paragraph are the four arguments of the function call in the pseudocode. Notice also that one typical way to write the connect statement is aligning the arguments like this, because then the first column (first and third arguments) are object instances that answer “where?” and the second column (second and fourth arguments) are functions that answer “what?”.

In C++ instead of pseudocode, and using real life objects and classes, this would look like this in Qt4 or earlier:

That could be a typical statement from a “Hello World” tutorial, where a button is created and shown, and when it’s pressed the whole window closes and the application terminates.

Now to the main point that I want you to notice here. This has a very subtle advantage over a typical mechanism used in standard C or C++ 11 like callbacks with function pointers and lambda functions wrapped in std::function, and is subtle only because is so nice we often forget about it when we have used signals and slots for a while. If the sender object is destroyed, it obviously can not emit any signal because it is a member function of its class. But for the sender to call the receiver, it needs a pointer to it, and you as a user, don’t need to worry at all about the receiver being destroyed and becoming invalid (that is done automatically by the library), so you very rarely need to call QObject::disconnect.

So signals and slots are very safe by default, and in an automatic way.

The new versus the old way to use connect

The previous example shows one way that works across old versions of Qt published so far (Qt 1 to 5). Recently a blog post about porting a tutorial application from Qt 1 to Qt 5.11 has been published, and no porting was needed at all for signals, slots, or the connections! That doesn’t mean the feature is perfect, since a new way to make connections was added, keeping all the previous functionality.

The main problem with the example above is that (as you probably knew, or guessed from being all uppercase) is that SIGNAL and SLOT are macros, and what those macros do is convert to a string the argument passed. This is a problem because any typo in what gets passed to those means that the call to connect would fail and return false. So since Qt 5.0, a new overload to QObject::connect exists, and supports passing as second and fourth arguments a function pointer to specify which member function should be called. Ported to the new syntax, the above example is:

Now any typo in the name will produce a compile time error. If you misspelled “click” with “clik” in the first example, that would only fail printing a warning in the console when that function gets called. If you did that in some dialog of an application you would have to navigate to that dialog to confirm that it worked! And it would be even more annoying if you were connecting to some error handling, and is not that easy to trigger said error. But if you did the same typo in the last example, it would be a compile time error, which is clearly much better.

This example is usually said to be using the “new syntax”, and the previous example the “old syntax”. Just remember that the old is still valid, but the new is preferred in most situations.

Since this is an exciting new feature added to a new major version, which has received some extra polishing during the minor releases, many blog posts from other members of the Qt community have been published about it (for example covering implementation details or the issues that could arise when there are arguments involved). I won’t cover those topics again, and instead I will focus on the details that in my experience would be most beneficial for people to read on.

No need to declare members as slots anymore (or almost)

The new syntax allows to call not just a member function declared as slot in the header with public slots: (or with protected or private instead of public), but any kind of function (more on that in the next section). There is still one use case where you would want to declare functions as slots, and that is if you want to make that function usable by any feature that happens at run time. That could be QML, for example.

Connecting to anything callable

Now we can connect to any “callable”, which could be a free standing function, a lambda function or a member function of an object that doesn’t derive from QObject. That looks in code like the following:

But wait, where is that nice symmetry with 2 rows and two columns now?

When you connect to a lambda, there is a receiver object, the lambda itself, but there is no signature to specify since it’s the function call operator (the same would happen to a function object or “functor”, by the way). And when there is a free standing function there is a signature, but there is no instance, so the third and the fourth arguments of the first two calls are somewhat merged. Note that the arguments are still checked at compile time: the signal has no arguments, and the lambda has no arguments either. Both sender and receiver are in agreement.

The example using std::bind requires a bit more explanation if you are not familiar with it. In this case we have the two objects and the two function pointers, which is to be expected for what is wanted. We don’t often think about it like this, but we always need a pointer to call a member function (unless it is static). When it is not used, it is because this is implicit, and this->call() can be shortened to call(). So what std::bind does here is create a callable object that glues together the particular instance that we want with one member function. We could do the same with a lambda:

Note that std::bind is actually much more powerful, and can be very useful when the number of arguments differ. But we will leave that topic to another article.

One common use of the above pattern with std::bind is when you have a class implemented through a data pointer (private implementation or pimpl idiom). If you need a button or a timer to call a member function of the private class that is not going to be a QObject, you can write something like this:

Recovering symmetry, safety and convenience

With the previous examples that nice balance of the four arguments is gone. But we are missing something more important.

What would happen if the lambda of the previous examples would use an invalid pointer? In the very first C++ example we showed a button wanting to close the application. Imagine that the button required to close a dialog, or stop some network request, etc. If the object is destroyed because said dialog is already closed or the request finished long ago, we want to manage that automatically so we don’t use an invalid pointer.

An example. For some reason you show some widget and you need to do some last minute update after it has been shown. It needs to happen soon but not immediately, so you use a timer with a short timeout. And you write

That works, but has a subtle problem. It could be that the widget gets shown and immediately closed. The timer under the scenes doesn’t know that, and it will happily call you, and crash the application. If you made the timer connect to a slot of the widget, that won’t happen: as soon as the dialog goes away, the connection gets broken.

Since Qt 5.2 we can have the best of both worlds, and recover that nice warm feeling of having a well balanced connect statement with two objects and two functions. 🙂

In that Qt version an additional overload was added to QObject::connect, and now there is the possibility to pass as third argument a so called “context object”, and as fourth argument the same variety of callables shown previously. Then the context object serves the purpose of automatically breaking the connection when the context is destroyed. That warranties the problem mentioned is now gone. You can easily handle that there are no longer invalid captures on a lambda.

The previous example is almost as the previous:

Now it is as if the lambda were a slot in your class, because to the timer, the context of the connection is the same.

The only requirement is that said context object has to be a QObject. This is not usually a problem, since you can create and ad-hoc QObject instance and even do simple but useful tricks with it. For example, say that you want to run a lambda only on the first click:

This will delete the ad-hoc QObject guard on the first invocation, and the connection will be automatically broken. The object also has the button as a parent, so it won’t be leaked if the button is never clicked and goes away (it will be deleted as well). You can use any QObject as context object, but the most common case will be to shut down timers, processes, requests, or anything related to what your user interface is doing when some dialog, window or panel closes.

Tip: There are utility classes in Qt to handle the lifetime of QObjects automatically, like QScopedPointer and QObjectCleanupHandler. If you have some part of the application using Qt classes but no UI tightly related to that, you can surely find a way to leverage those as members of a class not based on QObject. It is often stated as a criticism to Qt, that you can’t put QObjects in containers or smart pointers. Often the alternatives do exist and can be as good, if not better (but admittedly this is a matter of taste).

Bonus point: thread safety by thread affinity

The above section is the main goal of this article. The context object can save you crashes, and having to manually disconnect. But there is one additional important use of it: making the signal be delivered in the thread that you prefer, so you can save from tedious and error prone locking.

Again, there is one killer feature of signals and slots that we often ignore because it happens automatically. When one QObject instance is the receiver of a signal, its thread affinity is checked, and by default the signal is delivered directly as a function call when is the same thread affinity of the sender. But if the thread affinity differs, it will be delivered posting an event to the object. The internals of Qt will convert that event to a function call that will happen in the next run of the event loop of the receiver, so it will be in the “normal” thread for that object, and you often can forget about locks entirely. The locks are inside Qt, because QCoreApplication::postEvent (the function used to add the event to the queue) is thread-safe. In case of need, you can force a direct call from different threads, or a queued call from the same thread. Check the fifth argument in the QObject::connect documentation (it’s an argument which defaults to Qt::AutoConection).

Let’s see it in a very typical example.

This shows a class that derives from QRunnable to reimplement the run() function, and that derives from QObject to provide the finished() signal. An instance is created after the user activates a button, and then we show some progress bar and run the task. But we want to notify the user when the task is done (show some message, hide some progress bar, etc.).

In the above example, the third argument (context object) might be forgotten, and the code will compile and run, but it would be a serious bug. It would mean that you would attempt to call into the UI thread from the thread where the task was run (which is a helper thread pool, not the UI thread). This is wrong, and in some cases Qt will nicely warn you that you are using some function from the wrong thread, but if you are not lucky, you will have a mysterious crash.

Wrap up

Hopefully now you’ve understood why that odd point was made in the introduction section. You don’t have to agree that it is aesthetically pleasing to write the arguments to connect in two rows and two columns, but if you understood the importance of using a context object as a rule of thumb, you probably will find your preferred way to remember if that third argument is needed when you write (or review other’s) code using connect.

The QThread class provides a platform-independent way to managethreads. More...

Inherits QObject.

Types

• enum Priority { IdlePriority, LowestPriority, LowPriority, NormalPriority, ..., InheritPriority }

Methods

• int exec_ (self)
• bool isFinished (self)
• Priority priority (self)
• run (self)
• setStackSize (self, int stackSize)
• start (self, Priority priority = QThread.InheritPriority)
• bool wait (self, int msecs = ULONG_MAX)

Static Methods

• int currentThreadId ()
• msleep (int)
• sleep (int)
• yieldCurrentThread ()

Qt Signals

• void started ()

Detailed Description

The QThread class provides a platform-independent way to managethreads.

A QThread object manages one thread of control within theprogram. QThreads begin executing in run(). By default, run() starts the event loop by callingexec_() and runs a Qt event loopinside the thread.

You can use worker objects by moving them to the thread usingQObject.moveToThread().

The code inside the Worker's slot would then execute in aseparate thread. However, you are free to connect the Worker'sslots to any signal, from any object, in any thread. It is safe toconnect signals and slots across different threads, thanks to amechanism called queuedconnections.

Another way to make code run in a separate thread, is tosubclass QThread and reimplement run(). For example:

In that example, the thread will exit after the run function hasreturned. There will not be any event loop running in the threadunless you call exec_().

It is important to remember that a QThread instance lives in the old thread thatinstantiated it, not in the new thread that calls run(). This means that all of QThread'squeued slots will execute in the old thread. Thus, a developer whowishes to invoke slots in the new thread must use the worker-objectapproach; new slots should not be implemented directly into asubclassed QThread.

When subclassing QThread, keep in mind that the constructorexecutes in the old thread while run() executes in the new thread. If amember variable is accessed from both functions, then the variableis accessed from two different threads. Check that it is safe to doso.

Note: Care must be taken when interacting with objectsacross different threads. See Synchronizing Threads fordetails.

Managing threads

QThread will notifiy you via a signal when the thread isstarted(), finished(), and terminated(), or you can use isFinished() and isRunning() to query the state of thethread.

You can stop the thread by calling exit() or quit(). In extreme cases, you may want toforcibly terminate() anexecuting thread. However, doing so is dangerous and discouraged.Please read the documentation for terminate() and setTerminationEnabled()for detailed information.

From Qt 4.8 onwards, it is possible to deallocate objects thatlive in a thread that has just ended, by connecting the finished() signal to QObject.deleteLater().

Use wait() to block the callingthread, until the other thread has finished execution (or until aspecified time has passed).

The static functions currentThreadId() and currentThread() return identifiersfor the currently executing thread. The former returns a platformspecific ID for the thread; the latter returns a QThreadpointer.

To choose the name that your thread will be given (as identifiedby the command ps -L on Linux, for example), you can callsetObjectName() beforestarting the thread. If you don't call setObjectName(), the name givento your thread will be the class name of the runtime type of yourthread object (for example, 'RenderThread' in the case ofthe Mandelbrot Example, asthat is the name of the QThread subclass). Note that this iscurrently not available with release builds on Windows.

QThread also provides static, platform independent sleepfunctions: sleep(), msleep(), and usleep() allow full second, millisecond,and microsecond resolution respectively.

Note:wait() and thesleep() functions should beunnecessary in general, since Qt is an event-driven framework.Instead of wait(), considerlistening for the finished()signal. Instead of the sleep()functions, consider using QTimer.

{Mandelbrot Example}, {Semaphores Example}, {Wait ConditionsExample}

Type Documentation

QThread.Priority

Method Documentation

QThread.__init__ (self, QObjectparent = None)

The parent argument, if not None, causes self to be owned by Qt instead of PyQt.

Constructs a new QThread to manage anew thread. The parent takes ownership of the QThread. The thread does not begin executinguntil start() is called.

See alsostart().

QThread QThread.currentThread ()

Returns a pointer to a QThread whichmanages the currently executing thread.

int QThread.currentThreadId ()

int QThread.exec_ (self)

Enters the event loop and waits until exit() is called, returning the value thatwas passed to exit(). The valuereturned is 0 if exit() is calledvia quit().

This function is meant to be called from within run(). It is necessary to call this functionto start event handling.

See alsoquit() andexit().

QThread.exit (self, int returnCode = 0)

After calling this function, the thread leaves the event loopand returns from the call to QEventLoop.exec(). The QEventLoop.exec() function returnsreturnCode.

By convention, a returnCode of 0 means success, anynon-zero value indicates an error.

Note that unlike the C library function of the same name, thisfunction does return to the caller -- it is event processingthat stops.

No QEventLoops will be started anymore in this thread untilQThread.exec() has been calledagain. If the eventloop in QThread.exec() is not running then thenext call to QThread.exec() willalso return immediately.

See alsoquit() andQEventLoop.

int QThread.idealThreadCount ()

bool QThread.isFinished (self)

See alsoisRunning().

bool QThread.isRunning (self)

See alsoisFinished().

QThread.msleep (int)

See alsosleep() andusleep().

Priority QThread.priority (self)

Returns the priority for a running thread. If the thread is notrunning, this function returns InheritPriority.

This function was introduced in Qt 4.1.

See alsoPriority, setPriority(), and start().

QThread.quit (self)

See alsoexit() andQEventLoop.

QThread.run (self)

The starting point for the thread. After calling start(), the newly created thread callsthis function. The default implementation simply calls exec_().

You can reimplement this function to facilitate advanced threadmanagement. Returning from this method will end the execution ofthe thread.

See alsostart() andwait().

QThread.setPriority (self, Prioritypriority)

This function sets the priority for a running thread. Ifthe thread is not running, this function does nothing and returnsimmediately. Use start() to starta thread with a specific priority.

The priority argument can be any value in theQThread.Priority enum except forInheritPriorty.

The effect of the priority parameter is dependent on theoperating system's scheduling policy. In particular, thepriority will be ignored on systems that do not supportthread priorities (such as on Linux, seehttp://linux.die.net/man/2/sched_setscheduler for moredetails).

This function was introduced in Qt 4.1.

See alsoPriority, priority(), and start().

QThread.setStackSize (self, int stackSize)

See alsostackSize().

QThread.setTerminationEnabled (bool enabled = True)

Enables or disables termination of the current thread based onthe enabled parameter. The thread must have been started byQThread.

Qt Signal Slot Class

When enabled is false, termination is disabled. Futurecalls to QThread.terminate()will return immediately without effect. Instead, the termination isdeferred until termination is enabled.

When enabled is true, termination is enabled. Futurecalls to QThread.terminate()will terminate the thread normally. If termination has beendeferred (i.e. QThread.terminate() was called withtermination disabled), this function will terminate the callingthread immediately. Note that this function will not returnin this case.

See alsoterminate().

QThread.sleep (int)

See alsomsleep() andusleep().

int QThread.stackSize (self)

Returns the maximum stack size for the thread (if set withsetStackSize()); otherwisereturns zero.

See alsosetStackSize().

QThread.start (self, Prioritypriority = QThread.InheritPriority)

This method is also a Qt slot with the C++ signature void start(QThread::Priority = QThread.InheritPriority).

Begins execution of the thread by calling run(). The operating system will schedulethe thread according to the priority parameter. If thethread is already running, this function does nothing.

The effect of the priority parameter is dependent on theoperating system's scheduling policy. In particular, thepriority will be ignored on systems that do not supportthread priorities (such as on Linux, seehttp://linux.die.net/man/2/sched_setscheduler for moredetails).

See alsorun() andterminate().

QThread.terminate (self)

Terminates the execution of the thread. The thread may or maynot be terminated immediately, depending on the operating system'sscheduling policies. Listen for the terminated() signal, or use QThread.wait() after terminate(), to besure.

When the thread is terminated, all threads waiting for thethread to finish will be woken up.

Warning: This function is dangerous and its use isdiscouraged. The thread can be terminated at any point in its codepath. Threads can be terminated while modifying data. There is nochance for the thread to clean up after itself, unlock any heldmutexes, etc. In short, use this function only if absolutelynecessary.

Termination can be explicitly enabled or disabled by callingQThread.setTerminationEnabled().Calling this function while termination is disabled results in thetermination being deferred, until termination is re-enabled. Seethe documentation of QThread.setTerminationEnabled()for more information.

See alsosetTerminationEnabled().

QThread.usleep (int)

See alsosleep() andmsleep().

bool QThread.wait (self, int msecs = ULONG_MAX)

Qt Signal Slot Same Classic

• The thread associated with this QThread object has finished execution (i.e. whenit returns from run()). Thisfunction will return true if the thread has finished. It alsoreturns true if the thread has not been started yet.
• time milliseconds has elapsed. If time isULONG_MAX (the default), then the wait will never timeout (thethread must return from run()). Thisfunction will return false if the wait timed out.

This provides similar functionality to the POSIXpthread_join() function.

See alsosleep() andterminate().

QThread.yieldCurrentThread ()

Qt Signal Documentation

void finished ()

See alsostarted() andterminated().

Qt Signal Slot Performance

void started ()

Qt Signal Slot Example

See alsofinished()and terminated().

void terminated ()

Qt Signal Slot Same Classifieds

See alsostarted() andfinished().

Qt Signal Slot Thread