Python TKinter GUI关闭后进程无法终止问题求助

你的代码无法优雅退出的核心原因是socket线程卡在server_socket.accept()的阻塞调用中，即使设置了stop_flag，线程也无法跳出循环，导致Python进程无法完全终止。此外，退出逻辑没有等待socket线程结束就直接关闭TK窗口，也会导致残留线程挂住进程。

关键修复点： #

• 给server_socket设置超时，让它定期检查stop_flag，避免永久阻塞在accept
• 在quit_me方法中先设置stop_flag，再等待socket线程结束，最后关闭TK窗口
• 优化超时逻辑，避免重复调用quit_me
• 处理线程退出时的socket资源释放

修改后的完整代码： #

import tkinter as tk
import socket
import threading
import sys
import time
from queue import Queue

g_strSERVER = "127.0.0.1"
g_lPORT = int(sys.argv[1])
g_lTIMEOUT = 2  # 测试用短超时

def F_WND_CenterWindow(oWindow, lTargetWidth, lTargetHeight):
    lScreenWidth = oWindow.winfo_screenwidth()
    lScreenHeight = oWindow.winfo_screenheight()

    x = (lScreenWidth - lTargetWidth) // 2
    y = (lScreenHeight - lTargetHeight) // 2

    oWindow.geometry(f"{lTargetWidth}x{lTargetHeight}+{x}+{y}")

class clsMessageWindow:
    def __init__(self):
        self.root = tk.Tk()
        self.root.protocol("WM_DELETE_WINDOW", self.quit_me)
        self.root.title("日志显示")
        print("初始化日志窗口")

        # 设置窗口大小
        lTargetWindowWidth = 640
        lTargetWindowHeight = 380

        # 居中并置顶
        F_WND_CenterWindow(self.root, lTargetWidth=lTargetWindowWidth, lTargetHeight=lTargetWindowHeight)
        self.root.wm_attributes("-topmost",1)
        
        self.text_widget = tk.Text(self.root)
        self.text_widget.pack()

        self.queue = Queue()
        self.stop_flag = threading.Event()  # 线程停止信号
        self.socket_thread = threading.Thread(target=self.start_socket_server, daemon=True)  # 设置为守护线程，防止主线程退出后残留
        self.socket_thread.start()
        print("日志窗口初始化完成")
        self.last_message_received_at = time.time()

    def start_socket_server(self):
        server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        server_socket.settimeout(1)  # 设置1秒超时，定期检查stop_flag
        server_socket.bind((g_strSERVER, g_lPORT))
        server_socket.listen(1)
        print(f"服务器启动，监听 {g_strSERVER}:{g_lPORT}")

        while not self.stop_flag.is_set():
            try:
                oClientSocket, _ = server_socket.accept()
                strMessageData = oClientSocket.recv(1024).decode("utf-8")
                arrSplitMessage = strMessageData.split('\n')
                strMessage = arrSplitMessage[-1].strip()  # 去除空白字符，避免接收空消息
                print(f"收到消息: {strMessage}")

                if strMessage == "STOP":
                    print("收到STOP指令")
                    self.stop_flag.set()
                elif strMessage:  # 非空消息才加入队列
                    print(f"消息加入队列: {strMessage}")
                    self.queue.put(strMessage)
                    self.last_message_received_at = time.time()
                oClientSocket.close()
            except socket.timeout:
                # 超时是正常情况，继续循环检查stop_flag
                continue
            except Exception as e:
                print(f"错误: {e}")
                break

        # 关闭socket资源
        server_socket.close()
        print("socket服务器已关闭")

    def process_queue(self):
        while not self.queue.empty():
            strMessage = self.queue.get()
            self.add_message(strMessage)

        if not self.stop_flag.is_set():
            # 检查超时
            current_time = time.time()
            if current_time - self.last_message_received_at > g_lTIMEOUT:
                print("超时，准备退出")
                self.stop_flag.set()
                self.quit_me()
            else:
                # 继续定时检查
                self.root.after(100, self.process_queue)
        else:
            self.quit_me()

    def quit_me(self):
        print("开始优雅退出")
        # 确保stop_flag已设置
        self.stop_flag.set()
        # 等待socket线程结束（最多等2秒，避免无限等待）
        if self.socket_thread.is_alive():
            self.socket_thread.join(timeout=2)
        # 关闭TK窗口
        self.root.quit()
        self.root.destroy()
        print("退出完成")

    def add_message(self, strMessage):
        self.text_widget.insert(tk.END, strMessage + "\n")
        self.text_widget.see(tk.END)

    def run(self):
        self.process_queue()
        self.root.mainloop()

if __name__ == '__main__':
    message_window = clsMessageWindow()
    message_window.run()

修复说明： #

1. socket超时设置：给server_socket设置1秒超时，这样accept()会定期返回，线程可以检查stop_flag是否设置，避免永久阻塞。
2. 守护线程：将socket线程设为守护线程，即使主线程意外退出，守护线程也会自动终止。
3. 退出逻辑优化：quit_me方法中先设置stop_flag，再等待socket线程结束（带超时），最后关闭TK窗口，确保所有线程都能正常退出。
4. 消息处理优化：去除消息中的空白字符，避免空消息干扰超时判断。
5. 超时逻辑调整：只有在未设置stop_flag时才检查超时，避免重复调用quit_me。

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