如何让PyQt5中类的所有函数在独立线程运行且不重复创建线程？

你的问题核心不是方案选错了，而是调用函数的方式不对——直接调用worker的方法会让代码在当前线程（主线程）执行，自然会阻塞。只要调整调用方式，就能让所有函数复用同一个子线程执行，完全满足你的需求。

问题根源 #

当你把SAM_worker通过moveToThread()移到子线程后，只有通过信号槽连接或者QMetaObject.invokeMethod()触发的方法，才会在子线程中执行。直接调用worker.config_model(img)这种写法，本质是在主线程里执行该函数，必然阻塞。

正确实现方案 #

1. 改造SAM_worker类 #

给需要在子线程执行的方法加上@pyqtSlot装饰器（规范信号槽识别），并通过信号传递返回值（子线程方法无法直接返回结果给主线程）：

from PyQt5.QtCore import QObject, pyqtSignal, pyqtSlot, QMetaObject, Qt
from segment_anything import SamPredictor, sam_model_registry
import config


class SAM_worker(QObject):
    ready = pyqtSignal()
    predict_finished = pyqtSignal(object)  # 用信号传递预测结果

    def __init__(self, cuda, parent=None):
        super().__init__(parent)
        self.cuda = cuda
        self.predictor = None

    @pyqtSlot(object)
    def config_model(self, img):
        self.sam = sam_model_registry[config.MODEL_TYPE](config.CHECK_POINT)
        if self.cuda:
            self.sam.to(device='cuda')
        self.predictor = SamPredictor(self.sam)
        self.set_image(img)
        self.ready.emit()

    @pyqtSlot(object)
    def set_image(self, img):
        if self.predictor is not None:
            self.predictor.set_image(img, 'BGR')

    @pyqtSlot(object, dict)
    def predict(self, args, kwargs):
        if self.predictor is not None:
            result = self.predictor.predict(*args, **kwargs)
            self.predict_finished.emit(result)

2. 主线程中正确调用 #

创建线程并绑定worker，通过信号槽或invokeMethod触发子线程方法：

from PyQt5.QtCore import QThread
# 假设你在主窗口类中使用
class MainWindow(QMainWindow):
    def __init__(self):
        super().__init__()
        # 1. 创建线程和worker
        self.sam_thread = QThread()
        self.sam_worker = SAM_worker(cuda=True)
        self.sam_worker.moveToThread(self.sam_thread)

        # 2. 绑定线程生命周期信号（避免内存泄漏）
        self.sam_thread.started.connect(lambda: print("SAM子线程启动"))
        self.sam_thread.finished.connect(self.sam_thread.deleteLater)
        self.sam_worker.destroyed.connect(lambda: print("SAM worker释放"))

        # 3. 绑定业务信号
        self.sam_worker.ready.connect(self.on_sam_ready)
        self.sam_worker.predict_finished.connect(self.on_predict_result)

        # 4. 启动线程
        self.sam_thread.start()

    def init_sam_model(self, img):
        # 方式一：用自定义信号触发（推荐，解耦性强）
        # 先在MainWindow中定义信号：init_sam_signal = pyqtSignal(object)
        # self.init_sam_signal.connect(self.sam_worker.config_model)
        # self.init_sam_signal.emit(img)

        # 方式二：直接用invokeMethod调用
        QMetaObject.invokeMethod(
            self.sam_worker, 
            "config_model", 
            Qt.QueuedConnection,
            Q_ARG(object, img)
        )

    def run_predict(self, args, kwargs):
        QMetaObject.invokeMethod(
            self.sam_worker, 
            "predict", 
            Qt.QueuedConnection,
            Q_ARG(object, args),
            Q_ARG(dict, kwargs)
        )

    def on_sam_ready(self):
        print("SAM模型初始化完成")

    def on_predict_result(self, result):
        # 在主线程处理预测结果
        print("预测结果已返回", result)

为什么不推荐继承QThread？ #

PyQt官方明确推荐QObject+QThread的组合，原因如下：

• QThread本质是线程管理器，不是业务逻辑载体。继承它后，只有run()方法会在子线程执行，其他方法默认还是在主线程跑，反而需要额外处理线程切换，代码更复杂。
• QObject+QThread的方式可以让多个业务方法复用同一个子线程，完全符合你“无需每次创建新线程”的需求，灵活性更高。

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