如何在 Python 项目中全局共享并复用单个类实例？

通过模块级单例 + 多线程协同，可在同一进程内让多个逻辑模块（如 gui 和网络监听）安全共用同一个类实例，避免重复初始化导致的状态隔离问题。

在 Python 中，“跨文件共享同一个对象实例”这一需求看似简单，实则常因误解执行模型而失败。你当前的结构——分别运行 monitor.py 和 main.py 两个独立进程——本质上是两个完全隔离的 Python 解释器实例。即使它们都导入了 button.py，其中的 my_button = MyButtons() 也会被各自执行一次，生成两个互不相干的对象。这是进程隔离的底层机制决定的，与导入路径或模块缓存无关。

✅ 正确解法：将 GUI 主循环与业务逻辑（如 Socket 监听）合并至单个进程，并采用多线程协作模式。这样所有模块共享同一内存空间，button.py 中的 my_button 实例自然成为全局唯一对象。

✅ 推荐重构方案（单进程 + 双线程）

首先，修改 button.py，确保其设计支持线程安全（尤其注意 Tkinter 的 GUI 操作必须在主线程执行）：

# frontend/modules/button.py
import math
from frontend.utilities.screen_info import screen_info
from frontend.env import BTN_SIZE, SUCCESS_COLOR, FAIL_COLOR, WARNING_COLOR, BTN_X_PADDING, BTN_Y_PADDING
from frontend.modules.master import master, Button
from backend.ip_list import ip_list

screen_width, screen_height = screen_info()


class MyButtons:
    def __init__(self):
        self.current_btn = None
        self.btns = []
        self.items = ip_list
        self.attach_all_buttons()

    def create_btn(self, item, k):
        btn = Button(
            master,
            text=item,
            bg=FAIL_COLOR,
            command=lambda: self.click_btn(k)
        )
        self.btns.append(btn)
        self.current_btn = btn

    def click_btn(self, id):
        # 注意：Tkinter 方法调用必须在主线程！
        if self.btns[id].cget('bg') == WARNING_COLOR:
            self.btns[id].config(bg=SUCCESS_COLOR)

    def update_btns(self, items):
        # ✅ 安全更新：仅在主线程调用此方法（由主线程调度）
        for i, item in enumerate(items[:len(self.btns)]):  # 防越界
            bg_color = SUCCESS_COLOR if item.get('is_alive', False) else FAIL_COLOR
            self.btns[i].config(bg=bg_color)

    def configure_btn(self, col):
        master.grid_columnconfigure(col, minsize=BTN_SIZE)

    def attach_btn(self, row, col):
        self.current_btn.grid(
            row=row,
            column=col,
            padx=BTN_X_PADDING,
            pady=BTN_Y_PADDING,
            sticky='wens'
        )

    def attach_all_buttons(self):
        items_count = len(self.items)
        cols = max(1, math.floor(screen_width / BTN_SIZE))  # 防除零
        rows = math.ceil(items_count / cols)
        k = 0
        for row in range(rows):
            partial_items = self.items[row * cols:(row + 1) * cols]
            for col, item in zip(range(cols), partial_items):
                self.create_btn(item, k)
                self.attach_btn(row, col)
                self.configure_btn(col)
                k += 1


# ✅ 模块级单例：整个进程内仅此一份
my_button = MyButtons()

然后，废弃独立运行 monitor.py 和 main.py 的方式，新建统一入口 app.py：

立即学习“Python免费学习笔记（深入）”；

# app.py —— 唯一启动文件
import threading
import time
import pickle
from frontend.modules.button import my_button
from frontend.client_socket import client_socket
from frontend.modules.monitor import prepare_monitor  # 假设已将 monitor 逻辑封装为函数


def network_listener():
    """后台线程：持续接收 socket 数据并触发 UI 更新"""
    while True:
        try:
            data = client_socket.client_socket.recv(4096)
            if not data:
                break
            msg = pickle.loads(data)
            if msg:
                print('Received server data:', msg)
                # ✅ 关键：通过 after() 将 UI 更新调度到主线程（Tkinter 线程安全）
                master.after(0, my_button.update_btns, msg)
                client_socket.message = None
        except Exception as e:
            print("Socket error:", e)
            break
        time.sleep(0.1)  # 避免忙等待


if __name__ == "__main__":
    # 启动 GUI 主线程（负责渲染和事件响应）
    gui_thread = threading.Thread(target=prepare_monitor, daemon=False)
    gui_thread.start()

    # 启动网络监听后台线程（非阻塞、不干扰 GUI）
    listener_thread = threading.Thread(target=network_listener, daemon=True)
    listener_thread.start()

    # 保持主线程活跃（GUI 主循环已在 prepare_monitor 中启动）
    # 注意：Tkinter 的 mainloop() 必须在主线程运行，因此 prepare_monitor 应直接调用 master.mainloop()
    try:
        # 若 prepare_monitor 已含 mainloop()，此处无需额外阻塞
        # 否则可加：gui_thread.join()
        pass
    except KeyboardInterrupt:
        print("Shutting down...")

⚠️ 关键注意事项

• Tkinter 线程限制：所有 Button.config()、widget.grid() 等 GUI 操作必须在主线程执行。使用 master.after(0, func, *args) 是安全调度到主线程的标准做法。
• 避免竞态条件：若 MyButtons 中有非 GUI 状态（如 self.current_btn），且被多线程读写，需添加 threading.Lock 保护。
• Socket 连接管理：确保 client_socket 在主线程初始化，且连接未被多线程并发关闭。
• 进程 ≠ 线程：python monitor.py 和 python main.py 是两个进程 → 不可能共享内存；而 threading.Thread 是同一进程内的并发执行 → 共享全部全局变量和对象实例。

✅ 总结

要真正实现“项目内单例复用”，核心不是“怎么导入”，而是确保所有逻辑运行在同一进程内。通过 threading 将 GUI 渲染与后台通信解耦，既满足实时性要求，又严格遵守 Tkinter 的线程约束。button.py 中的 my_button 因模块单例特性天然成为全局唯一实例，无需额外单例模式（如 __new__ 魔术方法），简洁且可靠。