Python 如何推迟QRunnable的执行，直到发出前一个的信号

为了不冻结PyQT GUI，我使用了QRunnable（要在后台执行的函数）和QThreadPool。我有三个函数，其中一个函数需要前两个函数的结果才能运行，我正在努力确保在前两个函数返回各自的结果之后开始执行第三个函数

QThreadPool的类按以下方式定义：

class Worker(QtCore.QRunnable):
'''
Worker thread

Inherits from QRunnable to handler worker thread setup, signals and wrap-up.

:param callback: The function callback to run on this worker thread. Supplied args and
                 kwargs will be passed through to the runner.
:type callback: function
:param args: Arguments to pass to the callback function
:param kwargs: Keywords to pass to the callback function

'''

def __init__(self, fn, *args, **kwargs):
    super(Worker, self).__init__()

    # Store constructor arguments (re-used for processing)
    self.running = None
    self.fn = fn
    self.args = args
    self.kwargs = kwargs
    self.signals = WorkerSignals()

    # Add the callback to our kwargs
    self.kwargs['callback_progress'] = self.signals.progress
    self.kwargs['callback_data'] = self.signals.data

# @Slot()
def run(self):
    '''
    Initialise the runner function with passed args, kwargs.
    '''

    # Retrieve args/kwargs here; and fire processing using them
    try:
        self.signals.started.emit()
        self.result = self.fn(
            *self.args,
            **self.kwargs
        )
    except:
        traceback.print_exc()
        exctype, value = sys.exc_info()[:2]
        self.signals.error.emit((exctype, value, traceback.format_exc()))
    else:
        self.signals.result.emit(self.result)  # Return the result of the processing
    finally:
        self.signals.finished.emit()  # Done

和信号

class WorkerSignals(QtCore.QObject):
    '''
    Defines the signals available from a running worker thread.

    Supported signals are:

    finished
        No data

    error
        `tuple` (exctype, value, traceback.format_exc() )

    result
        `object` data returned from processing, anything

    progress
        `int` indicating % progress

    '''
    error = QtCore.Signal(tuple)
    started = QtCore.Signal()
    finished = QtCore.Signal()
    progress = QtCore.Signal(int)
    result = QtCore.Signal(object)
    data = QtCore.Signal(dict)

要执行的函数由以下函数调用

def exe_worker_run(self, WorkerPool, function, arguments):
    Worker = thread.Worker(function, arguments)
    Worker.signals.started.connect(self.sig_thread_start)
    Worker.signals.error.connect(self.sig_thread_error)
    Worker.signals.result.connect(self.sig_thread_result)
    Worker.signals.finished.connect(self.sig_thread_finish)
    WorkerPool.start(Worker)

发出结果的信号连接到函数

def sig_thread_result(self, result):
    for key in result.keys():
        try:
            dfrm = getattr(self, key)
            print('{} {} loaded!!!'.format(time.time(), key))
        except:
            pass

---

主要问题是每个函数的结果都是在所有函数完成执行后发出的。因此，我需要的是一种解决方案，它允许在上一个QRunnable的结果可用之前保持QRunnable的执行。

您可以将任务组织到队列中，并通过信号槽机制逐个传递给工作人员执行任务。通过这种方式，您可以使用一次计算的结果来安排下一次计算

从PySide2导入QtCore、QtWidgets、QtGui
课堂任务：
定义初始化（self，taskId）：
self.\u taskId=taskId
def任务ID（自身）：
返回自我。\u任务ID
def execute（）：
通过
类任务Plusone（任务）：
def _u初始化（self、taskId、value）：
super（）。\uuuu初始化（taskId）
自我价值=价值
def执行（自我）：
QtCore.QThread.currentThread（）.sleep（3）
返回self.\u值+1
类工作者（QtCore.QObject）：
完成=QtCore.Signal（int，object）
def追加（自我、任务）：
打印（“执行”，task.taskId（））
res=task.execute（）
self.complete.emit（task.taskId（），res）
类窗口（qtwidts.QWidget）：
task=QtCore.Signal（对象）
def uuu init uuu（self，parent=None）：
super（）。\uuuu init\uuuu（父级）
工人=工人（）
self.task.connect（worker.append）
worker.complete.connect（self.onComplete）
thread=QtCore.QThread（）
worker.moveToThread（线程）
thread.start（）
self.\u thread=线程
自我。_工人=工人
self.\u队列=[TaskPlusOne（0,0）]
self.executeOne（）
def executeOne（自我）：
队列=self.\u队列
如果len（queue）==0：
打印（“任务队列为空”）
返回
self.task.emit（queue.pop（0））
def executeAll（自我）：
当len（self.\u队列）>0时：
self.executeOne（）
def onComplete（自我、任务ID、资源）：
打印（“未完成”，任务ID）
如果res<2：
打印（“将任务附加到队列”）
self._queue.append（TaskPlusOne（taskId+1，res））
self.executeOne（）
def关闭事件（自身、事件）：
线程=自线程
thread.quit（）
线程。等待（）
super（）.closeEvent（事件）
如果名称=“\uuuuu main\uuuuuuuu”：
app=QtWidgets.QApplication（[]）
widget=Window（）
widget.show（）
app.exec()

谢谢你的回答。当我单独运行时，您的代码似乎可以工作，但我想我对Python的知识有点缺乏，无法将您的想法融入到代码中。