如何在 Python 项目中全局共享单个类实例？_技术教程

python 中跨模块复用同一对象实例需避免重复初始化；通过模块级单例 + 线程协同，可在 gui 主循环与后台逻辑间安全共享状态。

在你的项目中，monitor.py 和 main.py 被作为两个独立进程运行（即分别执行 python monitor.py 和 python main.py），这导致 button.py 中的 my_button = MyButtons() 被执行了两次——每次启动都创建一个全新的 MyButtons 实例。进程间内存隔离决定了它们无法共享对象状态，即使导入同一模块，也完全是两套独立的变量和对象。

✅ 正确做法是：将 GUI 显示与后台数据处理整合到单个进程中，并通过多线程协同工作。GUI 主循环（mainloop()）必须运行在主线程（Tkinter 不支持多线程调用 UI），而网络监听、数据更新等耗时操作应放在子线程中，二者通过共享的模块级单例对象通信。

✅ 推荐架构：单进程 + 双线程 + 模块单例

首先，确保 button.py 保持当前结构（它已是模块级单例雏形），但需增强线程安全性：

# frontend/modules/button.py
import math
import threading
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._lock = threading.RLock()  # 可重入锁，防嵌套调用死锁
        self.attach_all_buttons()

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

    def click_btn(self, id):
        with self._lock:
            if id < len(self.btns) and self.btns[id].cget('bg') == WARNING_COLOR:
                self.btns[id].config(bg=SUCCESS_COLOR)

    def update_btns(self, items):
        with self._lock:
            for i, item in enumerate(items[:len(self.btns)]):  # 防越界
                bg_color = SUCCESS_COLOR if item.get('is_alive') 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):
        with self._lock:
            if self.current_btn:
                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 = max(1, math.ceil(items_count / cols))
        k = 0
        for row in range(rows):
            start_idx, end_idx = row * cols, (row + 1) * cols
            partial_items = self.items[start_idx:end_idx]
            for col, item in zip(range(len(partial_items)), partial_items):
                self.create_btn(item, k)
                self.attach_btn(row, col)
                self.configure_btn(col)
                k += 1

# ✅ 模块级唯一实例（单例）
my_button = MyButtons()

然后，废弃双进程方案，改用单入口 main.py 启动完整应用：

# main.py
import threading
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 数据并更新按钮"""
    while True:
        try:
            data = client_socket.client_socket.recv(4096)
            if not data:
                break
            message = pickle.loads(data)
            if message:
                print('Received from server:', message)
                my_button.update_btns(message)  # 安全更新 UI 状态
        except Exception as e:
            print("Network error:", e)
            break

if __name__ == "__main__":
    # ✅ 启动 GUI 主线程（必须在主线程）
    gui_thread = threading.Thread(target=prepare_monitor, daemon=False)
    gui_thread.start()  # 注意：Tkinter 必须在主线程运行，此处 prepare_monitor 应直接调用 mainloop()

    # ✅ 启动网络监听子线程
    net_thread = threading.Thread(target=network_listener, daemon=True)
    net_thread.start()

    # ✅ 主线程交由 Tkinter 控制（关键！）
    # 注意：prepare_monitor 函数内部应直接调用 master.mainloop()
    # 不要在此处再调用 join()，否则会阻塞 GUI

⚠️ 关键注意事项：

Tkinter 限制：mainloop() 必须在主线程执行，任何 after()、update() 或事件回调也都在主线程。因此 UI 更新（如 update_btns）虽在子线程调用，但实际 config() 操作需确保线程安全（我们已用 RLock 保护）。
避免 daemon=False 的 GUI 线程：若 prepare_monitor() 内部调用 mainloop()，它会阻塞主线程，此时应让 mainloop() 直接在 if __name__ == "__main__": 下执行，网络线程设为 daemon=True。
更健壮的 UI 更新方式（推荐）：使用 master.after(10, lambda: my_button.update_btns(...)) 将更新请求投递到主线程，彻底规避线程竞争：
```
def safe_update_btns(self, items):
    master.after(0, lambda: self.update_btns(items))  # 立即调度到主线程
```