Python中如何访问在另一线程实例化的自定义QObject？

核心原因 #

Qt中QQmlApplicationEngine运行在主线程，而你在工作线程创建的MyClass对象属于该工作线程的上下文。QML不允许直接连接不同线程中的QObject——这违反了Qt的线程亲和性规则，因此触发非法连接错误。

修改方案 #

方案1：主线程创建MyClass对象，子线程仅执行其方法 #

如果MyClass的核心逻辑不需要在子线程初始化，直接在主线程实例化对象，再传递给工作线程执行耗时操作：

from PyQt5.QtCore import QThread, QObject, pyqtSignal, pyqtSlot
from PyQt5.QtQml import QQmlApplicationEngine
from PyQt5.QtWidgets import QApplication
import sys

class MyClass(QObject):
    updateSignal = pyqtSignal(str)

    @pyqtSlot()
    def doWork(self):
        # 执行耗时操作
        self.updateSignal.emit("工作完成")

class WorkerThread(QThread):
    def __init__(self, my_obj):
        super().__init__()
        self.my_obj = my_obj

    def run(self):
        self.my_obj.doWork()
        self.quit()

class Controller(QObject):
    startWork = pyqtSignal()

    def __init__(self):
        super().__init__()
        # 主线程创建MyClass对象
        self.my_obj = MyClass()
        self.thread = WorkerThread(self.my_obj)
        self.startWork.connect(self.thread.start)
        self.my_obj.updateSignal.connect(self.onUpdate)

    @pyqtSlot(str)
    def onUpdate(self, msg):
        print(msg)

if __name__ == "__main__":
    app = QApplication(sys.argv)
    engine = QQmlApplicationEngine()
    controller = Controller()
    engine.rootContext().setContextProperty("controller", controller)
    # 安全暴露主线程的MyClass给QML
    engine.rootContext().setContextProperty("myClass", controller.my_obj)
    engine.load("main.qml")
    sys.exit(app.exec_())

方案2：子线程创建对象后，移动到主线程 #

如果必须在子线程初始化MyClass，创建完成后立即将其移动到主线程，再暴露给QML：

class WorkerThread(QThread):
    objCreated = pyqtSignal(QObject)

    def run(self):
        my_obj = MyClass()
        # 将对象转移到主线程
        my_obj.moveToThread(QApplication.instance().thread())
        self.objCreated.emit(my_obj)
        self.quit()

class Controller(QObject):
    def __init__(self):
        super().__init__()
        self.thread = WorkerThread()
        self.thread.objCreated.connect(self.onObjCreated)
        self.thread.start()

    def onObjCreated(self, my_obj):
        # 此时my_obj属于主线程，可安全暴露给QML
        engine.rootContext().setContextProperty("myClass", my_obj)

方案3：通过控制器中转所有跨线程交互（最安全） #

不让QML直接接触子线程对象，所有交互通过主线程的Controller中转，由控制器处理跨线程信号槽连接：

class MyClass(QObject):
    workDone = pyqtSignal(str)

    @pyqtSlot()
    def doWork(self):
        # 子线程内执行工作
        self.workDone.emit("工作完成")

class WorkerThread(QThread):
    def __init__(self):
        super().__init__()
        self.my_obj = MyClass()
        self.my_obj.moveToThread(self)  # 绑定对象到当前线程

    def run(self):
        self.exec_()

class Controller(QObject):
    startWork = pyqtSignal()
    workUpdate = pyqtSignal(str)

    def __init__(self):
        super().__init__()
        self.worker_thread = WorkerThread()
        # 跨线程连接自动使用QueuedConnection，保证线程安全
        self.startWork.connect(self.worker_thread.my_obj.doWork)
        self.worker_thread.my_obj.workDone.connect(self.workUpdate)
        self.worker_thread.start()

if __name__ == "__main__":
    app = QApplication(sys.argv)
    engine = QQmlApplicationEngine()
    controller = Controller()
    engine.rootContext().setContextProperty("controller", controller)
    engine.load("main.qml")
    sys.exit(app.exec_())

对应的QML代码（仅与主线程的controller交互）：

import QtQuick 2.15
import QtQuick.Controls 2.15

ApplicationWindow {
    visible: true
    width: 400
    height: 300

    Button {
        text: "开始工作"
        onClicked: controller.startWork()
    }

    Label {
        id: statusLabel
        text: ""
        anchors.top: Button.bottom
        anchors.topMargin: 20
        Connections {
            target: controller
            onWorkUpdate: statusLabel.text = msg
        }
    }
}

关键注意事项 #

• 作为QML上下文属性的对象，必须始终属于主线程（QML引擎所在线程）。
• 跨线程信号槽连接时，显式指定Qt.QueuedConnection可避免潜在的线程安全问题。
• 不要在子线程中创建需要直接与QML交互的QObject，除非后续将其转移到主线程。

内容的提问来源于stack exchange，提问作者emg184