基于Tkinter的多窗口GUI进程控制咨询：用多线程还是多进程？

首先直接给结论：你只需要用多线程就完全足够了，不需要用到多进程。原因有两个：

• Tkinter的GUI组件必须在主线程中操作，多进程会导致跨进程访问GUI元素的问题，进程间通信的复杂度远高于线程间通信；
• 你的需求是暂停/恢复主窗口的数值更新，以及在新窗口运行任务，这些都可以通过线程间的状态控制轻松实现，完全没必要引入多进程的开销。

接下来看你的现有代码，核心问题是没有真正控制worker线程的运行状态——虽然你设置了self.gui.pause，但workerThread1里的循环并没有检查这个状态，所以线程会一直往队列里塞数据；另外temp_process方法的作用也不明确，我们可以调整代码来实现你的需求：

修改后的完整代码 #

import tkinter
import time
import threading
import random
import queue

class GuiPart:
    def __init__(self, master, queue, endCommand, newWindow):
        self.queue = queue
        # Set up the GUI
        console = tkinter.Button(master, text='Done', command=endCommand)
        console.pack()
        console2 = tkinter.Button(master, text='New', command=newWindow)
        console2.pack()
        self.output = tkinter.StringVar(value="0.0")
        output_1_label = tkinter.Label(master, textvariable=self.output, height=2, width=12)
        output_1_label.pack()

    def processIncoming(self):
        """处理队列中的更新消息"""
        while self.queue.qsize():
            try:
                msg = self.queue.get_nowait()
                self.output.set(f"{msg:.2f}")
            except queue.Empty:
                pass

class ThreadedClient:
    def __init__(self, master):
        self.master = master
        self.queue = queue.Queue()
        # 用Event来实现线程安全的暂停/恢复控制
        self.pause_event = threading.Event()
        self.pause_event.set()  # 初始状态为运行（不暂停）
        
        self.gui = GuiPart(master, self.queue, self.endApplication, self.create_window)
        self.running = True
        # 主窗口的更新线程
        self.worker_thread = threading.Thread(target=self.worker_task, daemon=True)
        self.worker_thread.start()
        # 定期处理队列消息
        self.periodic_call()

    def create_window(self):
        """打开新窗口并暂停主线程更新"""
        self.pause_event.clear()  # 设置暂停状态
        self.new_window = tkinter.Toplevel(self.master)
        self.new_window.title("新窗口")
        # 在新窗口中运行自己的任务线程
        self.new_window_thread = threading.Thread(target=self.new_window_task, daemon=True)
        self.new_window_thread.start()
        
        # 关闭新窗口时恢复主线程
        self.new_window.protocol("WM_DELETE_WINDOW", self.on_new_window_close)

    def on_new_window_close(self):
        """关闭新窗口后的处理"""
        self.pause_event.set()  # 恢复主线程更新
        self.new_window.destroy()

    def worker_task(self):
        """主窗口的数值更新任务"""
        while self.running:
            self.pause_event.wait()  # 如果暂停则阻塞在这里
            time.sleep(random.random())
            msg = random.random() * 100  # 生成0-100的随机数，方便观察
            self.queue.put(msg)

    def new_window_task(self):
        """新窗口的任务示例"""
        count = 0
        # 模拟新窗口的任务运行，直到窗口关闭
        while hasattr(self, 'new_window') and self.new_window.winfo_exists():
            print(f"新窗口任务运行中：第{count}次")
            count +=1
            time.sleep(1)

    def periodic_call(self):
        """定期处理队列中的GUI更新"""
        self.gui.processIncoming()
        if self.running:
            self.master.after(100, self.periodic_call)  # 缩短间隔，让GUI响应更流畅

    def endApplication(self):
        """关闭整个应用"""
        self.running = False
        self.pause_event.set()  # 唤醒可能阻塞的线程
        self.master.destroy()

if __name__ == "__main__":
    root = tkinter.Tk()
    root.title("主窗口")
    client = ThreadedClient(root)
    root.mainloop()

关键改动说明 #

• 用threading.Event实现线程安全的暂停/恢复：pause_event是线程安全的同步原语，clear()会让线程阻塞在wait()处，set()会唤醒线程继续运行，比直接用布尔变量更可靠，避免线程间的竞态条件。
• 分离GUI逻辑和线程逻辑：把主窗口的更新任务和新窗口的任务分别放在独立的线程中，都设置为daemon=True，这样主程序退出时线程会自动结束。
• 新窗口的任务处理：新窗口的任务在独立线程中运行，不会阻塞主线程的GUI循环，同时通过检查窗口是否存在来控制任务的结束。
• 优化GUI更新频率：把periodic_call的间隔从1000ms改成100ms，让GUI更新更及时，避免队列堆积。

这样修改后，你打开新窗口时主窗口的数值会停止更新，新窗口的任务开始运行；关闭新窗口后，主窗口的数值更新会自动恢复。

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