How to use QThread correctly in pyqt with moveToThread()?

The default run() implementation in QThread runs an event loop for you, the equivalent of:

class GenericThread(QThread):    def run(self, *args):        self.exec_()

The important thing about an event loop is that it allows objects owned by the thread to receive events on their slots, which will be executed in that thread. Those objects are just QObjects, not QThreads.

Important note: the QThread object is not owned by its own thread! It was created on the main thread and lives there. Apart from its run method, all of its code executes in the main thread.

So you should be able to do this:

class GenericWorker(QObject):    def __init__(self, function, *args, **kwargs):        super(GenericWorker, self).__init__()        self.function = function        self.args = args        self.kwargs = kwargs        self.start.connect(self.run)    start = pyqtSignal(str)    @pyqtSlot    def run(self, some_string_arg):        self.function(*self.args, **self.kwargs)my_thread = QThread()my_thread.start()# This causes my_worker.run() to eventually execute in my_thread:my_worker = GenericWorker(...)my_worker.moveToThread(my_thread)my_worker.start.emit("hello")

Also, think carefully about what happens with the result of self.function, which is currently discarded. You could declare another signal on GenericWorker, which receives the result, and have the run() method emit that signal when it's done, passing the result to it.

Once you get the hang of it and realize you don't and shouldn't subclass QThread, life becomes a lot more straightforward and easier. Simply put, never do work in QThread. You should almost never need to override run. For most use cases, setting up proper associations with a QObject to a QThread and using QT's signals/slots creates an extremely powerful way to do multithreaded programming. Just be careful not to let the QObjects you've pushed to your worker threads hang around...

http://ilearnstuff.blogspot.co.uk/2012/09/qthread-best-practices-when-qthread.html

I was attempting to use qris's example in my application, but kept having my code run in the my main thread! It is the way the signal that he declared to call run!

Basically, when you connect it in the constructor of the object, the connection will exist between two objects in the main thread - because the QObject's properties belong to the thread that created them. When you move the QObject to your new thread, the connection doesn't move with you. Take away the line that connects your signal to the run function, and connect it after you move the worker to its new thread!

The relevant change from qris's answer:

class GenericWorker(QObject):    def __init__(self, function, *args, **kwargs):        super(GenericWorker, self).__init__()        self.function = function        self.args = args        self.kwargs = kwargs    start = pyqtSignal(str)    @pyqtSlot    def run(self, some_string_arg):        self.function(*self.args, **self.kwargs)my_thread = QThread()my_thread.start()# This causes my_worker.run() to eventually execute in my_thread:my_worker = GenericWorker(...)my_worker.moveToThread(my_thread)my_worker.start.connect(my_worker.run) #  <---- Like this instead my_worker.start.emit("hello")

I've tried both @qris and @MatthewRunchey approaches.

With the @pyqtSlot decorator Qt checks the "location" of the worker instance when the signal is emitted: even if the connection was made before moveToThread emitting the signal after moveToThread executes the slot in the worker thread.

Without the @pyqtSlot decorator Qt freezes the "location" of the worker instance the moment when the connection was made: if it was before moveToThread, it is bound to the main thread, and the slot code keeps being executed in the main thread even if the signal is emitted after moveToThread call.

Connections made after moveToThread bind the slot to be executed the worker thread in both cases.

Code:

import threadingfrom PyQt5.QtCore import (QCoreApplication, QObject, QRunnable, QThread,                          QThreadPool, pyqtSignal, pyqtSlot)class Worker(QObject):    def __init__(self):        super(Worker, self).__init__()#        self.call_f1.connect(self.f1)#        self.call_f2.connect(self.f2)    call_f1 = pyqtSignal()    call_f2 = pyqtSignal()    @pyqtSlot()    def f1(self):        print('f1', threading.get_ident())        @pyqtSlot()    def f2(self):        print('f2', threading.get_ident())app = QCoreApplication([])print('main', threading.get_ident())my_thread = QThread()my_thread.start()my_worker = Worker()my_worker.call_f1.connect(my_worker.f1)my_worker.call_f1.emit()my_worker.moveToThread(my_thread)my_worker.call_f2.connect(my_worker.f2)my_worker.call_f1.emit()my_worker.call_f2.emit()sys.exit(app.exec_())

With decorator:

main 18708f1 18708f1 20156f2 20156

Without decorator:

main 5520f1 5520f1 5520f2 11472

PS Connecting in the worker __init__ method is obviously equivalent to connecting before moveToThread in the main thread.

(tested under PyQt5, win64).