Gtk应用中Python多进程回调失效致程序挂起的解决方法

一、修复现有代码的挂起问题 #

你的代码挂起主要有两个核心原因：

1. Gtk.main_quit()在GLib超时回调的上下文里直接调用，可能无法立即触发主循环退出；
2. 子进程未正常终止，即便主循环退出，主进程仍可能等待子进程。

修复后的完整代码 #

import multiprocessing
import queue
import collections
import gi
gi.require_version("Gtk", "3.0")
from gi.repository import GLib, Gtk

Msg = collections.namedtuple("Msg", ["event", "args"])


class BaseProcess(multiprocessing.Process):
    "基于内部队列实现消息通信的进程基类"

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.requests = multiprocessing.Queue()
        self.responses = multiprocessing.Queue()

    def send(self, event, *args, finished_callback=None):
        "将事件和参数封装为Msg放入请求队列"
        msg = Msg(event, args)
        self.requests.put(msg)
        if finished_callback:
            GLib.timeout_add(100, self._monitor_process, finished_callback)

    def run(self):
        while True:
            try:
                msg = self.requests.get()
                event, args = msg
                if event == "quit":
                    break
                handler = getattr(self, f"do_{event}", None)
                if not handler:
                    raise NotImplementedError(f"Process has no handler for [{event}]")
                result = handler(*args)
                self.responses.put(result)
            except Exception as e:
                print(f"子进程出错: {e}", flush=True)
                break

    def _monitor_process(self, finished_callback):
        try:
            result = self.responses.get(False)
            if finished_callback is not None:
                finished_callback(result)
            return GLib.SOURCE_REMOVE
        except queue.Empty:
            return GLib.SOURCE_CONTINUE
        except Exception as e:
            print(f"轮询出错: {e}", flush=True)
            return GLib.SOURCE_REMOVE

class MyProcess(BaseProcess):
    "测试进程类"

    def do_sum(self, arg1, arg2):
        "求和测试方法"
        print(f"do_sum {arg1 + arg2}", flush=True)
        return arg1 + arg2


def finished_callback(result):
    print(f"result {result}", flush=True)
    # 先给子进程发送退出信号
    process.send('quit')
    # 用idle_add确保主循环正确处理退出逻辑
    GLib.idle_add(Gtk.main_quit)

if __name__ == "__main__":
    # 强制使用spawn启动方式，规避GLib与fork的兼容问题
    multiprocessing.set_start_method('spawn')
    process = MyProcess()
    process.start()
    process.send('sum', 1, 2, finished_callback=finished_callback)
    Gtk.main()
    # 等待子进程完全退出，避免僵尸进程
    process.join()

关键修复点 #

• 使用GLib.idle_add(Gtk.main_quit)延迟退出操作，确保主循环能正确处理退出信号；
• 在退出前给子进程发送quit事件，配合process.join()确保子进程正常终止；
• 添加multiprocessing.set_start_method('spawn')，规避GLib与fork模式的兼容冲突。

二、Gtk应用处理长耗时任务（如扫描器）的最佳实践 #

GLib与multiprocessing的兼容问题主要源于fork操作会破坏GLib的单线程上下文状态。针对扫描器这类长耗时任务，推荐以下两种方案：

方案1：使用GLib原生跨进程接口spawn_async #

GLib提供的spawn_async与主循环天然兼容，适合调用外部扫描工具的场景：

import gi
gi.require_version("Gtk", "3.0")
from gi.repository import GLib, Gtk

class ScannerWindow(Gtk.Window):
    def __init__(self):
        super().__init__(title="扫描器")
        self.button = Gtk.Button(label="开始扫描")
        self.button.connect("clicked", self.start_scan)
        self.add(self.button)

    def start_scan(self, widget):
        self.button.set_sensitive(False)
        # 调用外部扫描命令（示例为scanimage）
        pid, _, _, _ = GLib.spawn_async(
            ["scanimage", "--format=png", "--output-file=scan.png"],
            flags=GLib.SpawnFlags.SEARCH_PATH,
            standard_output=True,
            standard_error=True
        )
        # 监听进程退出事件
        GLib.child_watch_add(pid, self.on_scan_finished)

    def on_scan_finished(self, pid, status):
        self.button.set_sensitive(True)
        if status == 0:
            print("扫描完成")
        else:
            print(f"扫描失败，状态码: {status}")

if __name__ == "__main__":
    win = ScannerWindow()
    win.connect("destroy", Gtk.main_quit)
    win.show_all()
    Gtk.main()

方案2：multiprocessing + GLib.IO监听（替代轮询） #

如果需要自定义Python子进程逻辑，用multiprocessing.Pipe配合GLib.io_add_watch实现事件驱动通信，规避轮询的性能损耗：

import multiprocessing
import gi
gi.require_version("Gtk", "3.0")
from gi.repository import GLib, Gtk

def scanner_process(pipe):
    "模拟扫描耗时操作"
    import time
    time.sleep(3)
    pipe.send("扫描完成，生成文件: scan_123.png")
    pipe.close()

class ScannerWindow(Gtk.Window):
    def __init__(self):
        super().__init__(title="扫描器")
        self.button = Gtk.Button(label="开始扫描")
        self.button.connect("clicked", self.start_scan)
        self.add(self.button)
        self.process = None

    def start_scan(self, widget):
        self.button.set_sensitive(False)
        # 创建双向管道
        parent_pipe, child_pipe = multiprocessing.Pipe()
        # 启动子进程
        self.process = multiprocessing.Process(target=scanner_process, args=(child_pipe,))
        self.process.start()
        # 监听管道可读事件
        GLib.io_add_watch(
            parent_pipe.fileno(),
            GLib.IO_IN | GLib.IO_HUP,
            self.on_scan_result,
            parent_pipe
        )

    def on_scan_result(self, fd, condition, pipe):
        if condition & GLib.IO_IN:
            result = pipe.recv()
            print(result)
        # 清理资源
        self.process.join()
        self.button.set_sensitive(True)
        pipe.close()
        return GLib.SOURCE_REMOVE

if __name__ == "__main__":
    multiprocessing.set_start_method('spawn')
    win = ScannerWindow()
    win.connect("destroy", Gtk.main_quit)
    win.show_all()
    Gtk.main()

关键注意事项 #

• 绝对不要在子进程中调用任何Gtk/GLib API：Gtk绑定到主进程的主循环，子进程调用会直接崩溃；
• 进程间通信优先用Pipe而非Queue：Pipe更轻量，配合IO监听实现事件驱动，效率远高于轮询；
• 始终清理子进程：在窗口关闭或任务完成时，确保子进程被终止并回收；
• 强制使用spawn启动方式：避免fork模式破坏GLib的内部状态。

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