在嵌入式PyQt应用程序中使用QThread

Question

I have written a Qt application in c++ which embeds the Python interpreter and makes use of PyQt to allow for scriptable user interfaces for data analysis. The Python code does some computations on the data and returns a QWidget (containing various plots etc.) which gets inserted into the main application.

I would like to spawn a new QThread from Python to allow control to return to the c++ application so that heavy computations do not block the main thread in which the GUI runs. The problem is that as soon as control is returned back to the c++ application, the thread appears to go to sleep until the Python interpreter is somehow invoked again, eg. a mouseover event on a matplotlib plot. I suspect this is somehow due to Python's GIL.

How can I have a QThread created from Python continue to run after control passes back to the embedding application?

I am using the following code to test. The embedding application calls test_thread() and adds the returned container to a QTabwidget. The thread only executes as I generate mouse events over the matplotlib plot.

import time

from PyQt4 import QtCore, QtGui
from PyQt4.QtCore import pyqtSignal, pyqtSlot

from matplotlib.figure import Figure
from matplotlib.backends.backend_qt4agg import FigureCanvasQTAgg as FigureCanvas

app = QtGui.QApplication.instance()  

class Worker(QtCore.QObject):
    finished = pyqtSignal()

    def __init__(self):
        QtCore.QObject.__init__(self)

    def do_work(self):
        for i in range(0, 10):
            print 'worker running'
            time.sleep(1)

        self.finished.emit()


class Controller(QtCore.QObject):
    def __init__(self):
        QtCore.QObject.__init__(self)

        self.thread = QtCore.QThread()
        self.worker = Worker()
        self.worker.moveToThread(self.thread)
        self.worker.finished.connect(self.thread.quit)
        self.thread.started.connect(self.worker.do_work)
        self.thread.finished.connect(app.exit)

    def start_thread(self):
        self.thread.start()


class Container(QtGui.QWidget):
    def __init__(self):
        QtGui.QWidget.__init__(self)

        self.controller = Controller()
        self.controller.start_thread()

        self.fig = Figure(dpi=72, facecolor=(1, 1, 1), edgecolor=(0, 0, 0))
        self.fig.add_subplot(111)
        self.canvas = FigureCanvas(self.fig)

        self.layout = QtGui.QVBoxLayout()
        self.layout.addWidget(self.canvas)

        self.setLayout(self.layout)


def test_thread():
    container = Container()
    return container

Answer 1

CPython is single threaded because of GIL or Global Interpreter Lock. You cannot run more than 1 concurrent thread from python.

https://wiki.python.org/moin/GlobalInterpreterLock

Qt is not blocking you here, python is. The only workaround here is to spawn separate python process for your worker "thread" then use IPC (sockets, shared memory, etc) to communicate between processes. Qt provides interfaces for these IPC mechanisms. You will just have to serialize your interprocess communication.

• http://qt-project.org/doc/qt-5/QSharedMemory.html
• http://qt-project.org/doc/qt-5/QLocalSocket.html

This assumed you were asking about concurrency. Regarding something else, and editing answer to clarify jurisdiction,

How can I have a QThread created from Python continue to run after control passes back to the embedding application?

This is 100% up to the embedding application. The python interpreter must be allowed to continue to run by the embedding application. If the embedding application does not allow python to continue to run, then any attempts to circumvent this will result in problems.