PyQt5 - QMovie in MainWindow doesn't play even when using QThread

Question

I am trying to display a loading gif on my PyQt5 QMainWindow while an intensive process is running. Rather than playing normally, the QMovie pauses. As far as I can tell, the event loop shouldn't be blocked as the intensive process is in its own QObject passed to its own QThread. Relevant code below:

QMainWindow:

class EclipseQa(QMainWindow):

    def __init__(self):
        QMainWindow.__init__(self)
        self.initUI()

    def initUI(self):
        ...
        self.loadingMovie = QMovie("./loading.gif")
        self.loadingMovie.setScaledSize(QSize(149, 43))
        self.statusLbl = QLabel(self)
        self.statusLbl.setMovie(self.loadingMovie)
        self.grid.addWidget(self.statusLbl, 6, 2, 2, 2, alignment=Qt.AlignCenter)
        self.statusLbl.hide()
        ...

    def startLoadingGif(self):
        self.statusLbl.show()
        self.loadingMovie.start()

    def stopLoadingGif(self):
        self.loadingMovie.stop()
        self.statusLbl.hide()

    def maskDose(self):
        self.startLoadingGif()

        # Set up thread and associated worker object
        self.thread = QThread()
        self.worker = DcmReadWorker()
        self.worker.moveToThread(self.thread)
        self.worker.finished.connect(self.thread.quit)
        self.worker.updateRd.connect(self.updateRd)
        self.worker.updateRs.connect(self.updateRs)
        self.worker.updateStructures.connect(self.updateStructures)
        self.worker.clearRd.connect(self.clearRd)
        self.worker.clearRs.connect(self.clearRs)
        self.thread.started.connect(lambda: self.worker.dcmRead(caption, fname[0]))
        self.thread.finished.connect(self.stopLoadingGif)

        self.maskThread.start()

    def showDoneDialog(self):
        ...
        self.stopLoadingGif()
        ...

Worker class:

class DoseMaskWorker(QObject):
    clearRd = pyqtSignal()
    clearRs = pyqtSignal()
    finished = pyqtSignal()
    startLoadingGif = pyqtSignal()
    stopLoadingGif = pyqtSignal()
    updateMaskedRd = pyqtSignal(str)

    def __init__(self, parent=None):
        QObject.__init__(self, parent)

    @pyqtSlot(name="maskDose")
    def maskDose(self, rd, rdName, rdId, rs, maskingStructure_dict):
        ...
        self.updateMaskedRd.emit(maskedRdName)
        self.finished.emit()

For brevity, '...' indicates code that I figured is probably not relevant.

Answer 1

Your use of lambda to call the slot when the threads started signal is emitted is likely causing it to execute in the main thread. There are a couple of things you need to do to fix this.

Firstly, your use of pyqtSlot does not contain the types of the arguments to the maskDose method. You need to update it so that it does. Presumably you also need to do this for the dcmRead method which you call from the lambda but haven't included in your code. See the documentation for more details.

In order to remove the use of the lambda, you need to define a new signal and a new slot within the EclipseQa class. The new signal should be defined such that the required number of parameters for the dcmRead method are emitted, and the types correctly specified (documentation for this is also in the link above). This signal should be connected to the workers dcmRead slot (make sure to do it after the worker object has been moved to the thread or else you might run into this bug!). The slot should take no arguments, and be connected to the threads started signal. The code in the slot should simply emit your new signal with the appropriate arguments to be passed to dcmRead (e.g. like self.my_new_signal.emit(param1, param2)).

Note: You can check what thread any code is running in using the Python threading module (even when using QThreads) by printing threading.current_thread().name from the location you wish to check.

Note 2: If your thread is CPU bound rather than IO bound, you may still experience performance issues because of the Python GIL which only allows a single thread to execute at any one time (it will swap between the threads regularly though so code in both threads should run, just maybe not at the performance you expect). QThreads (which are implemented in C++ and are theoretically able to release the GIL) do not help with this because they are running your Python code and so the GIL is still held.