PyQt实现耗时函数计算不阻塞主线程的异步调用方案

Qt 没有提供可以直接在主线程挂起普通槽函数、等待异步操作完成后从原中断位置无缝恢复的原生机制——主线程的槽函数一旦运行，就会阻塞事件循环直到函数返回，不存在中途让出控制权给事件循环、之后再回到断点继续执行的原生能力（协程、生成器这类用户态调度方案除外）。
要实现无阻塞调用外部进程、完成后接续原有逻辑的效果，有3种成熟可落地的方案，按改造成本从低到高排序如下：

方案1：QProcess异步调用 + 逻辑拆分（Qt原生推荐，改造成本最低） #

直接替换阻塞的subprocess.run为Qt自带的QProcess异步执行接口，把原槽函数中阻塞点之后的逻辑，拆分绑定到QProcess的finished信号回调中即可，完全不会阻塞主事件循环。
改造示例代码：

from PyQt5.QtCore import QProcess

def slot1():
    # 此处可放进程启动前需要执行的前置逻辑
    proc = QProcess()
    # 绑定进程完成后的回调，后续逻辑全部放到回调中
    proc.finished.connect(lambda exit_code, exit_status: _slot1_after_proc(proc, exit_code, exit_status))
    proc.start("external proc")
    # 函数直接返回，事件循环正常运行，GUI不会冻结

def _slot1_after_proc(proc, exit_code, exit_status):
    # 读取进程输出、返回状态，和原subprocess.run拿到的结果完全一致
    stdout = proc.readAllStandardOutput().data().decode()
    stderr = proc.readAllStandardError().data().decode()
    status = (exit_code, stdout, stderr)
    # 原subprocess.run之后的所有业务逻辑，原封不动迁移到此处即可
    ...
    ...

注意：绝对不要调用QProcess.waitForFinished()，这个接口依然会阻塞主线程，必须用信号绑定回调的纯异步模式。如果多个槽的后续逻辑存在公共部分，可以抽离通用工具函数减少重复代码。

方案2：生成器实现伪挂起（几乎不改动原有线性代码结构） #

你提到的生成器思路完全可行，本质是把阻塞调用的位置设为yield断点，写一个通用调度器执行生成器：遇到yield返回的异步进程任务时，就暂停当前函数执行，等进程执行完成后把结果回传给生成器，从yield断点位置继续向后运行，几乎可以保留原有代码的线性书写逻辑，不需要把函数拆成多段。
实现示例：

from functools import wraps
from PyQt5.QtCore import QProcess, pyqtSignal, QObject

class AsyncRunner(QObject):
    # 通用生成器调度器
    def start(self, gen):
        try:
            task = next(gen)
            # 异步任务完成后，自动推进生成器到下一步
            def on_task_done(result):
                try:
                    gen.send(result)
                    self.start(gen)
                except StopIteration:
                    pass
            task.done.connect(on_task_done)
        except StopIteration:
            pass

# 包装QProcess为可被调度的异步任务
class ProcTask(QObject):
    done = pyqtSignal(tuple)
    def __init__(self, cmd):
        super().__init__()
        self.proc = QProcess()
        self.proc.finished.connect(self._on_finish)
        self.proc.start(cmd)
    def _on_finish(self, exit_code, exit_status):
        stdout = self.proc.readAllStandardOutput().data().decode()
        stderr = self.proc.readAllStandardError().data().decode()
        self.done.emit( (exit_code, stdout, stderr) )

# 槽函数改造，和原同步写法逻辑几乎一致
def slot1():
    status = yield ProcTask("external proc") # 执行到此处暂停，进程跑完自动接续
    # 后续逻辑原封不动保留
    ...
    ...

# 信号绑定阶段用调度器包装即可
runner = AsyncRunner()
button1.clicked.connect(lambda: runner.start(slot1()))
button2.clicked.connect(lambda: runner.start(slot2()))

方案3：协程原生支持（适合新项目/可接受全局事件循环改造的场景） #

如果你使用的是PyQt6/PySide6 6.2以上版本，Qt已经原生支持协程异步调度；也可以用qasync把Qt事件循环和Python原生asyncio打通，把阻塞的subprocess调用替换为异步子进程接口，用await实现自然挂起、恢复的效果，代码和同步写法完全一致：

import asyncio
from qasync import asyncSlot

@asyncSlot()
async def slot1():
    proc = await asyncio.create_subprocess_exec("external proc", stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE)
    stdout, stderr = await proc.communicate()
    status = (proc.returncode, stdout.decode(), stderr.decode())
    # await时会自动让出主线程控制权，GUI完全不卡顿
    ...
    ...

注意：该方案需要替换全局Qt事件循环为qasync实现，对老项目侵入性较强，存量项目不建议优先选择。

避坑提醒 #

• 不要图省事把subprocess.run扔到QThread里再用阻塞接口等待线程返回，这类写法如果涉及跨线程UI交互很容易触发线程安全问题，优先用QProcess原生异步信号机制，比手动管理线程更简单稳定。
• 外部进程执行期间记得临时禁用对应触发按钮，避免用户重复点击拉起多个冗余进程。
• 所有在主线程调用的阻塞等待类接口（包括QProcess.waitForFinished()、QThread.wait()、原生subprocess.run等）都会冻结GUI，必须全部替换为异步实现。

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