如何关闭运行计时进程的Python Tkinter番茄钟应用？

核心故障原因 #

你当前的代码直接在主线程中执行while死循环 + time.sleep(1)，完全阻塞了Tkinter的主事件循环。Tkinter所有界面交互（包括关闭按钮响应、界面重绘、控件状态更新）都依赖主事件循环调度，主线程被占住后自然无法响应关闭操作。
另外注意你代码里有变量拼写错误：循环内用的tiempo未定义，应该替换为你传入的参数time1。

最优解决方案：使用Tkinter内置after()方法 #

这是Tkinter生态下做定时任务的标准实现，不需要额外开启线程，也没有线程安全问题，比多线程方案更稳定简洁。
after()可以让Tkinter在指定毫秒数后异步调用目标函数，全程不阻塞主事件循环，界面操作完全不受影响。

修复后完整代码示例 #

import tkinter as tk

work_time = 25 * 60
time_rest = 5 * 60
BG_COLOR_work = "#f26419"
BG_COLOR_rest = "#86bbd8"

class TomatoTimer:
    def __init__(self):
        self.root = tk.Tk()
        self.root.title("番茄钟")
        # 状态变量
        self.timer_str = tk.StringVar(value="25:00")
        self.state_str = tk.StringVar(value="未开始")
        self.current_remain = 0
        self.after_task_id = None

        # 界面布局（可根据你的需求调整）
        tk.Label(self.root, textvariable=self.state_str, font=("微软雅黑", 14), bg="white").pack(pady=10)
        tk.Label(self.root, textvariable=self.timer_str, font=("微软雅黑", 30), bg="white").pack(pady=20)
        tk.Button(self.root, text="启动计时", command=self.start_work, font=("微软雅黑", 12)).pack(pady=10)

        # 绑定窗口关闭事件，提前清理待执行任务
        self.root.protocol("WM_DELETE_WINDOW", self.on_close)
        self.root.mainloop()

    def change_bg_color(self, color):
        self.root.config(bg=color)
        # 如有其他需要同步改色的控件，可在这里统一处理

    def start_work(self):
        # 重置为工作状态
        self.current_remain = work_time
        self.state_str.set("工作中")
        self.change_bg_color(BG_COLOR_work)
        self.run_timer()

    def run_timer(self):
        if self.current_remain >= 0:
            # 更新时间显示
            mins, secs = divmod(self.current_remain, 60)
            self.timer_str.set(f"{mins:02d}:{secs:02d}")
            self.current_remain -= 1
            # 1000毫秒后再次调用自身，实现每秒更新
            self.after_task_id = self.root.after(1000, self.run_timer)
        else:
            # 计时结束切换状态
            if self.state_str.get() == "工作中":
                self.current_remain = time_rest
                self.state_str.set("休息中")
                self.change_bg_color(BG_COLOR_rest)
            else:
                self.current_remain = work_time
                self.state_str.set("工作中")
                self.change_bg_color(BG_COLOR_work)
            self.after_task_id = self.root.after(1000, self.run_timer)

    def on_close(self):
        # 取消待执行的定时任务，避免残留任务报错
        if self.after_task_id:
            self.root.after_cancel(self.after_task_id)
        self.root.destroy()

if __name__ == "__main__":
    TomatoTimer()

备选方案：多线程实现 #

如果你的场景有更复杂的后台计算逻辑，确实需要用线程的话，要注意两个核心规则：

1. 所有Tkinter控件的操作必须放在主线程执行，子线程里要更新UI的话需要用after(0, 回调函数)把操作抛给主线程调度
2. 要给线程加退出标志，窗口关闭时主动通知线程终止，避免产生僵尸进程

核心逻辑示例 #

import threading
import time
# 常量定义和界面初始化部分同上
class TomatoTimer:
    def __init__(self):
        # 原有初始化代码
        self.thread_running = threading.Event()
        self.root.protocol("WM_DELETE_WINDOW", self.on_close)

    def start_work(self):
        self.thread_running.set()
        # 开守护线程跑计时逻辑，主进程退出时线程会自动销毁
        threading.Thread(
            target=self.count_time,
            args=(work_time,),
            daemon=True
        ).start()

    def count_time(self, time1):
        while time1 >= 0 and self.thread_running.is_set():
            mins, secs = divmod(time1, 60)
            counter = f"{mins:02d}:{secs:02d}"
            # 把UI更新操作抛到主线程执行
            self.root.after(0, lambda c=counter: self.timer_str.set(c))
            time.sleep(1)
            time1 -= 1
            if time1 <= 0 and self.thread_running.is_set():
                if self.state_str.get() == "工作中":
                    time1 = time_rest
                    self.root.after(0, lambda: self.state_str.set("休息中"))
                    self.root.after(0, lambda: self.change_bg_color(BG_COLOR_rest))
                else:
                    time1 = work_time
                    self.root.after(0, lambda: self.state_str.set("工作中"))
                    self.root.after(0, lambda: self.change_bg_color(BG_COLOR_work))

    def on_close(self):
        # 通知线程退出
        self.thread_running.clear()
        # 等待1秒让线程正常结束
        time.sleep(1)
        self.root.destroy()

总结 #

优先选择after()方案，没有额外依赖，也不会出现多线程场景下常见的UI更新异常、进程残留问题，是该类需求的最优实现。

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