As an educational project, I’m working on a Python application that involves multiple threads, each blocked on a synchronous socket read operation. I need these threads to also respond to two types of events: individual thread-specific events and broadcast events that all threads should respond to. The challenge is to handle these events without interrupting the blocking read on the socket.

Here’s what I’m trying to achieve:

• Each thread is continuously reading from its own dedicated socket.
• I need each thread to handle “personal” events and a “broadcast” event. The broadcast event should be received by all threads simultaneously without any one of them missing it due to others reading it first.

The solution needs to ensure that while a thread is blocked on a socket read, it can still react to the broadcast events. I’ve considered using select to monitor the sockets and other descriptors, but I’m unsure how to implement the broadcast mechanism properly. Here’s the conceptual approach I’ve thought about:

• Use os.pipe() to create communication channels for the personal and broadcast events.
• Use select.select() to wait on the sockets and these pipes simultaneously.

However, I’m struggling with the scenario where the broadcast event must be handled by all threads without any thread missing it because another has already read it. Here’s a rough sketch of what I’m thinking:

import select
import socket
import os
import threading

# Setup for sockets and pipes

def thread_function(sock, rfd):
    while True:
        readable, _, _ = select.select([sock, rfd], [], [])
        for r in readable:
            if r == sock:
                data = sock.recv(1024)  # Handle socket data
            elif r == rfd:
                os.read(rfd, 1024)  # Handle event

# Threads setup and event handling logic here

My questions are:

• How can I implement a broadcast event mechanism that ensures all threads receive the event without one consuming it before the others?
• Is there a better way to structure this system to handle both dedicated and broadcast events while keeping the socket read operations blocking?

Any insights, suggestions, or examples would be greatly appreciated. Thank you!