如何在 Python 项目中全局共享并复用同一个类实例_技术教程

通过模块级单例模式或线程内共享对象，可在整个项目中确保类的唯一实例被所有模块共同访问和修改，避免重复初始化导致的状态不一致问题。

在 Python 中，每个 python script.py 命令都会启动一个独立进程，拥有独立的内存空间和模块命名空间。因此，当你分别运行 python monitor.py 和 python main.py 时，尽管两者都导入了 frontend.modules.button，但 my_button = MyButtons() 在两个进程中各自执行一次，生成的是两个完全隔离、互不通信的对象实例——这正是你观察到“按钮状态无法同步”的根本原因。

✅ 正确解法不是“让两个进程共享对象”，而是将整个应用整合为单进程、多线程协作架构：GUI 主循环（mainloop()）与网络监听逻辑（start()）运行在同一进程中，通过线程安全的方式共享 MyButtons 实例。

✅ 推荐方案：单进程 + 主线程（GUI）+ 后台线程（Socket 监听）

修改 main.py，不再单独运行，而是作为主入口统一启动 GUI 和后台服务：

# main.py —— 新的统一入口
import threading
import time
from frontend.modules.button import my_button  # 全局唯一实例
from frontend.client_socket import client_socket
import pickle


def start_network_listener():
    """后台线程：持续接收 socket 数据并更新按钮"""
    while True:
        try:
            data = client_socket.client_socket.recv(4096)
            if not data:
                break
            msg = pickle.loads(data)
            if msg:
                # 线程安全调用（Tkinter 非线程安全，需注意！见下方说明）
                my_button.update_btns(msg)
                print('✓ Updated buttons with:', msg)
        except Exception as e:
            print('⚠ Socket error:', e)
            break


def prepare_monitor():
    """主线程：启动 Tkinter GUI 循环"""
    from frontend.modules.master import master
    master.mainloop()


if __name__ == "__main__":
    print("? Starting Network Monitor (GUI + Socket Listener)...")

    # 启动后台监听线程（守护线程，随主程序退出）
    listener_thread = threading.Thread(target=start_network_listener, daemon=True)
    listener_thread.start()

    # 主线程进入 GUI 循环（阻塞）
    prepare_monitor()

⚠️ 关键注意事项：Tkinter 线程安全限制master.mainloop() 必须运行在主线程，且 Tkinter 组件（如 Button.config()）不能直接从子线程调用，否则可能崩溃或无响应。你的 my_button.update_btns() 内部调用了 self.btns[i].config(...)，属于 Tkinter 操作——当前实现存在线程安全隐患。

✅ 安全增强：使用 after() 实现线程安全 UI 更新

修改 button.py，添加线程安全的更新机制：

# 在 button.py 的 MyButtons 类中新增：
import tkinter as tk

class MyButtons:
    def __init__(self):
        self.current_btn = None
        self.btns = []
        self.items = ip_list
        self.attach_all_buttons()
        # 新增：用于跨线程调度 UI 更新的引用
        self._root = None  # 将在 attach_all_buttons 中赋值
        self._pending_updates = []

    def attach_all_buttons(self):
        from frontend.modules.master import master
        self._root = master  # 保存对 Tk root 的引用
        # ...（原有 attach 逻辑保持不变）

    def update_btns_safe(self, items):
        """线程安全的更新入口：将更新任务投递到主线程"""
        self._pending_updates.append(items.copy())  # 浅拷贝防并发修改
        # 调度到主线程执行（仅当未在主线程中）
        if not self._root or not hasattr(self._root, 'after'):
            return
        self._root.after(0, self._apply_pending_updates)

    def _apply_pending_updates(self):
        """在 Tk 主线程中执行实际更新"""
        while self._pending_updates:
            items = self._pending_updates.pop(0)
            self.update_btns(items)  # 调用原始方法（此时在主线程）

然后在 main.py 的监听线程中调用：

# 替换原 update_btns 调用：
my_button.update_btns_safe(msg)  # ✅ 安全！

✅ 总结：单例共享的核心原则

❌ 错误思路：依赖多个进程间“共享对象”（Python 进程内存天然隔离，不可行）。
✅ 正确路径：
1. 单进程启动：所有逻辑（GUI + 网络）运行于同一进程；
2. 模块级单例：my_button = MyButtons() 在模块顶层定义，首次导入即创建，后续导入复用同一对象；
3. 线程协同：GUI 主线程 + 后台工作线程，通过 root.after() 或 queue.Queue 安全通信；
4. 避免全局变量污染：若需更严格控制，可将 my_button 封装为函数返回的单例（@staticmethod + __instance），但当前模块级方式已足够清晰可靠。