Qt Signal Slot Same Class

QtCore.SIGNAL and QtCore.SLOT macros allow Python to interface with Qt signal and slot delivery mechanisms. This is the old way of using signals and slots. The example below uses the well known clicked signal from a QPushButton. The connect method has a non python-friendly syntax. Detailed Description The QThread class provides a platform-independent way to manage threads. A QThread object manages one thread of control within the program. QThreads begin executing in run. I have a class X with a slot, and a class Y with a signal. I'm setting up the connection from class X, and created a public method in class Y to emit the signal from class X (I'm not sure this step was necessary). Then, if I call that method from class X, signal is emitted, and slot is executed.

Home · All Classes · Modules

One key and distinctive feature of Qt framework is the use of signals and slots to connect widgets and related actions. But as powerful the feature is, it may look compelling to a lot of developers not used to such a model, and it may take some time at the beginning to get used to understand how to use signals and slots properly. Therefore it is not usually necessary to use QtCore.SLOT for Qt slots. However, doing so is more efficient as it avoids a conversion to Python and back to C. Qt allows a signal to be connected to a slot that requires fewer arguments than the signal passes. The extra arguments are quietly discarded. PyQt4 slots can be used in the same way.

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

Inherits QObject.


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


  • 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.IdlePriority0scheduled only when no other threads arerunning.
QThread.LowestPriority1scheduled less often than LowPriority.
QThread.LowPriority2scheduled less often than NormalPriority.
QThread.NormalPriority3the default priority of the operatingsystem.
QThread.HighPriority4scheduled more often than NormalPriority.
QThread.HighestPriority5scheduled more often than HighPriority.
QThread.TimeCriticalPriority6scheduled as often as possible.
QThread.InheritPriority7use the same priority as the creating thread.This is the default.

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.

Qt Signals And Slots Tutorial

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.

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)

  • 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 ()

Qt signals and slots tutorial

See alsostarted() andterminated().

void started ()

See alsofinished()and terminated().

Qt Signal Slot Performance

void terminated ()

See alsostarted() andfinished().

PyQt 4.11.4 for X11Copyright © Riverbank Computing Ltd and The Qt Company 2015Qt 4.8.7

Demonstrates multi-thread programming using Qt.



In the Custom Type Example, we showed how to integrate custom types with the meta-object system, enabling them to be stored in QVariant objects, written out in debugging information and used in signal-slot communication.

In this example, we create a new value class, Block, and register it with the meta-object system to enable us to send instances of it between threads using queued signals and slots.

The Block Class

The Block class is similar to the Message class described in the Custom Type Example. It provides the default constructor, copy constructor and destructor in the public section of the class that the meta-object system requires. It describes a colored rectangle.

We will still need to register it with the meta-object system at run-time by calling the qRegisterMetaType() template function before we make any signal-slot connections that use this type. Even though we do not intend to use the type with QVariant in this example, it is good practice to also declare the new type with Q_DECLARE_METATYPE().

The implementation of the Block class is trivial, so we avoid quoting it here.

The Window Class

We define a simple Window class with a public slot that accepts a Block object. The rest of the class is concerned with managing the user interface and handling images.

Qt Signal Slot Class

The Window class also contains a worker thread, provided by a RenderThread object. This will emit signals to send Block objects to the window's addBlock(Block) slot.


The parts of the Window class that are most relevant are the constructor and the addBlock(Block) slot.

The constructor creates a thread for rendering images, sets up a user interface containing a label and two push buttons that are connected to slots in the same class.

In the last of these connections, we connect a signal in the RenderThread object to the addBlock(Block) slot in the window.

The rest of the constructor simply sets up the layout of the window.

The addBlock(Block) slot receives blocks from the rendering thread via the signal-slot connection set up in the constructor:

We simply paint these onto the label as they arrive.

The RenderThread Class

The RenderThread class processes an image, creating Block objects and using the sendBlock(Block) signal to send them to other components in the example.

The constructor and destructor are not quoted here. These take care of setting up the thread's internal state and cleaning up when it is destroyed.

Processing is started with the processImage() function, which calls the RenderThread class's reimplementation of the QThread::run() function:

Qt Signal Slot Same Class

Ignoring the details of the way the image is processed, we see that the signal containing a block is emitted in the usual way:

Each signal that is emitted will be queued and delivered later to the window's addBlock(Block) slot.

Registering the Type

In the example's main() function, we perform the registration of the Block class as a custom type with the meta-object system by calling the qRegisterMetaType() template function:

This call is placed here to ensure that the type is registered before any signal-slot connections are made that use it.

The rest of the main() function is concerned with setting a seed for the pseudo-random number generator, creating and showing the window, and setting a default image. See the source code for the implementation of the createImage() function.

Further Reading

This example showed how a custom type can be registered with the meta-object system so that it can be used with signal-slot connections between threads. For ordinary communication involving direct signals and slots, it is enough to simply declare the type in the way described in the Custom Type Example.

In practice, both the Q_DECLARE_METATYPE() macro and the qRegisterMetaType() template function can be used to register custom types, but qRegisterMetaType() is only required if you need to perform signal-slot communication or need to create and destroy objects of the custom type at run-time.

Qt Signal Slot Parameter

More information on using custom types with Qt can be found in the Creating Custom Qt Types document.

How Qt Signal And Slots Works


Qt Signal Slot Thread

© 2020 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.