Jakob the videos are brilliant, I have a question as I was trying to tackle this on my own...say we have 3 threads (0,1,2) and we want thread 0 to msg all threads (1 and 2) and then we have thread 1 doing the same with threads 0 and 2...and so forth, how do we go about that? I know its kind of similar to the producer/consumer example but in this case each thread can produce/consume messages as they arrive?

This is a classic problem in concurrent programming, and there are several ways to approach it. Here's a general outline of one possible solution using Python's threading and queue libraries:

1. Create a list of queues, one for each thread. These queues will be used to pass messages between threads.

import queue
import threading

num_threads = 3
queues = [queue.Queue() for _ in range(num_threads)]

2. Define a function for the threads to run. This function should take as arguments the thread's ID and the list of queues. Inside the function, the thread should loop indefinitely, checking its queue for messages and sending messages to the other threads.

def thread_func(thread_id, queues):
    while True:
        # Check for messages
        while not queues[thread_id].empty():
            msg = queues[thread_id].get()
            print(f"Thread {thread_id} received: {msg}")

        # Send messages to other threads
        for i in range(num_threads):
            if i != thread_id:
                queues[i].put(f"Hello from thread {thread_id}")

3. Create and start the threads, passing each one its ID and the list of queues.

threads = []
for i in range(num_threads):
    t = threading.Thread(target=thread_func, args=(i, queues))
    t.start()
    threads.append(t)

4. Wait for the threads to finish (which, in this case, they won't, since they loop indefinitely).

for t in threads:
    t.join()

This is a very basic example and doesn't include any error handling or cleanup code. In a real-world application, you'd want to make sure to handle exceptions and ensure that the threads are properly cleaned up when they're done.