Got it, let's tackle this problem head-on. You need to broadcast data updates to all clients via a multi-threaded server, then reset a specific object only after every send operation is complete—plus you have to respect Tkinter's thread-safety rules. Here's how to make this work reliably:

Core Concept: Thread Synchronization + Tkinter Thread Safety #

The key is tracking when all broadcast threads finish their work, then triggering your reset logic only in the Tkinter main thread (since Tkinter doesn't allow UI/state changes from background threads).

Option 1: Dynamic Client Count (Most Flexible) #

Use a thread-safe counter and event to track active broadcast threads. This works if clients connect/disconnect dynamically.

import threading
from tkinter import Tk, Button, Label

class MultiUserAppServer:
    def __init__(self, root):
        self.root = root
        self.clients = []  # Store active client connections
        self.counter_lock = threading.Lock()
        self.active_broadcast_threads = 0
        self.all_done_event = threading.Event()
        self.status_label = Label(root, text="Ready")
        self.status_label.pack(pady=10)

    def broadcast_data_update(self, new_data):
        # Reset state for new broadcast
        self.all_done_event.clear()
        with self.counter_lock:
            self.active_broadcast_threads = len(self.clients)
        
        if self.active_broadcast_threads == 0:
            # No clients to update—reset immediately
            self.root.after(0, self.reset_target_object)
            return

        # Spin up a thread for each client
        for client in self.clients:
            threading.Thread(
                target=self.send_update_to_client,
                args=(client, new_data),
                daemon=True
            ).start()
        
        # Start a watcher thread to wait for all broadcasts to finish
        threading.Thread(target=self.wait_for_broadcasts, daemon=True).start()

    def send_update_to_client(self, client, data):
        try:
            # Replace with your actual send logic (e.g., socket.send())
            print(f"Sending update to client {client}: {data}")
            # Simulate network delay
            import time
            time.sleep(0.5)
        except Exception as e:
            print(f"Failed to send to client {client}: {e}")
        finally:
            # Decrement counter safely
            with self.counter_lock:
                self.active_broadcast_threads -= 1
                # Trigger event when last thread finishes
                if self.active_broadcast_threads == 0:
                    self.all_done_event.set()

    def wait_for_broadcasts(self):
        # Block until all threads signal completion
        self.all_done_event.wait()
        # Schedule reset for the Tkinter main thread
        self.root.after(0, self.reset_target_object)

    def reset_target_object(self):
        # Your actual reset logic here (e.g., clear cache, refresh UI)
        self.status_label.config(text="All clients updated! Object reset.")
        print("Resetting specified object...")
        # Example: self.data_cache = {}

# Tkinter Main Thread Setup
if __name__ == "__main__":
    root = Tk()
    root.title("Multi-User App Server")
    server = MultiUserAppServer(root)
    
    # Simulate adding clients (replace with your connection logic)
    server.clients = ["Client1", "Client2", "Client3"]
    
    # Button to trigger data update broadcast
    trigger_btn = Button(
        root,
        text="Trigger Data Update",
        command=lambda: server.broadcast_data_update("New database records available!")
    )
    trigger_btn.pack(pady=20)
    
    root.mainloop()

Option 2: Fixed Client Count (Simpler) #

If you know the exact number of clients upfront, use threading.Barrier to wait for all threads to reach a "checkpoint" before proceeding:

def broadcast_data_update(self, new_data):
    if not self.clients:
        self.root.after(0, self.reset_target_object)
        return
    
    # Barrier waits for all client threads + 1 watcher thread
    broadcast_barrier = threading.Barrier(len(self.clients) + 1)
    
    for client in self.clients:
        threading.Thread(
            target=self.send_with_barrier,
            args=(client, new_data, broadcast_barrier),
            daemon=True
        ).start()
    
    # Wait for all threads to hit the barrier
    broadcast_barrier.wait()
    # Schedule reset in main thread
    self.root.after(0, self.reset_target_object)

def send_with_barrier(self, client, data, barrier):
    try:
        # Your send logic here
        print(f"Sent update to {client}: {data}")
    except Exception as e:
        print(f"Send failed for {client}: {e}")
    finally:
        # Ensure barrier is triggered even if send fails
        barrier.wait()

Critical Notes #

• Thread Safety for Tkinter: Never modify Tkinter widgets or app state directly from background threads. Use root.after(0, callback) to queue operations for the main thread—this prevents crashes and UI glitches.
• Error Handling: Always wrap send logic in try/finally to ensure your counter/barrier is updated even if a client disconnects mid-broadcast.
• Dynamic Client Lists: If clients connect/disconnect while a broadcast is in progress, add a lock around self.clients to avoid race conditions when reading/writing the list.

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