Tkinter更新Label组件时出现内存泄漏问题求助

你的内存泄漏核心原因是子线程直接操作Tkinter UI组件。Tkinter是单线程UI库，所有对UI元素的修改必须在创建它的主线程（即运行mainloop的线程）中执行。子线程直接修改Label['text']会破坏Tkinter内部的资源管理机制，导致无法正常释放内存，这也是内存分析工具指向更新文本代码行的原因。

另外你的threadlauncher方法每隔500ms就创建新线程，即使线程未启动，频繁创建的线程对象也会额外占用资源，加剧内存问题。

1. 用Tkinter原生的after()替代子线程更新UI #

对于倒计时这类周期性UI更新任务，完全不需要子线程，after()方法可以在主线程中实现定时循环，既安全又不会有内存泄漏。

2. Modbus查询放在子线程，但通过主线程更新UI #

如果Modbus查询是耗时操作，需要放在子线程执行，但查询完成后不能直接修改UI，要通过after()让主线程处理UI更新。

先修复你的复现代码 #

from tkinter import *
from tkinter.ttk import *
import time

class Window(Tk):
    def __init__(self):
        super().__init__()
        self.geometry("250x250")
        self.title("test")

        self.label = Label(self, text="a")
        self.label.pack()

        # 启动主线程定时更新，替代子线程
        self.update_label_loop()

    def update_label_loop(self):
        # 在主线程中更新Label文本
        self.label['text'] = f"updated label {time.time_ns()}"
        # 500ms后再次调用自己，实现循环更新
        self.after(500, self.update_label_loop)

if __name__ == "__main__":
    app = Window()
    app.mainloop()

适配你的Modbus查询+倒计时需求的完整代码 #

from tkinter import *
from tkinter.ttk import *
import threading
import time
import queue

class Window(Tk):
    def __init__(self):
        super().__init__()
        self.geometry("400x100")
        self.title("Modbus Query Monitor")

        # 倒计时Label
        self.countdown_label = Label(self, text="--- Waiting 120 seconds for new values ---")
        self.countdown_label.pack(pady=10)

        # 用于子线程传递Modbus数据的队列
        self.data_queue = queue.Queue()

        # 初始化倒计时参数
        self.query_interval = 120  # 2分钟
        self.remaining_time = self.query_interval

        # 启动倒计时更新循环
        self.update_countdown()
        # 启动Modbus查询线程（只启动一次）
        self.start_modbus_thread()

    def update_countdown(self):
        if self.remaining_time > 0:
            self.countdown_label['text'] = f"--- Waiting {self.remaining_time} seconds for new values ---"
            self.remaining_time -= 1
            # 1秒后更新一次倒计时
            self.after(1000, self.update_countdown)
        else:
            # 倒计时结束，触发查询并重置倒计时
            self.countdown_label['text'] = "--- Querying datas ---"
            self.remaining_time = self.query_interval
            # 立即启动下一轮倒计时
            self.after(1000, self.update_countdown)

    def start_modbus_thread(self):
        # 启动一个长期运行的子线程处理Modbus查询
        def modbus_query_loop():
            while True:
                # 模拟Modbus查询耗时操作
                time.sleep(self.query_interval)
                # 假设查询到的数据
                modbus_data = {"temp": 25, "pressure": 101}
                # 将数据放入队列，通知主线程更新UI
                self.data_queue.put(modbus_data)
                # 这里可以添加异常判断，若数据异常则传递标记

        thread = threading.Thread(target=modbus_query_loop, daemon=True)
        thread.start()
        # 启动主线程轮询队列，处理数据更新
        self.check_data_queue()

    def check_data_queue(self):
        try:
            while not self.data_queue.empty():
                data = self.data_queue.get_nowait()
                # 这里处理数据，比如异常时展示到窗口
                # 示例：更新Label显示数据
                self.countdown_label['text'] = f"Data: Temp={data['temp']}°C, Pressure={data['pressure']}kPa"
                # 延迟1秒后恢复倒计时
                self.after(1000, lambda: self.update_countdown())
        except queue.Empty:
            pass
        # 每隔100ms轮询一次队列
        self.after(100, self.check_data_queue)

if __name__ == "__main__":
    app = Window()
    app.mainloop()

• 所有UI更新操作（比如修改Label['text']）都在主线程中执行，通过after()调度，完全符合Tkinter的线程安全要求。
• Modbus查询这类耗时操作放在子线程，通过队列传递数据给主线程，避免阻塞UI。
• 倒计时用after()实现循环，不需要额外线程，彻底解决内存泄漏问题。

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