Using Message Passing to Transfer Data Between Threads

Message passing is a concurrency model where threads (or processes) communicate by sending and receiving messages rather than sharing memory directly. This approach fundamentally differs from shared-memory concurrency, which often requires explicit synchronization primitives like mutexes or semaphores to prevent data races and other concurrent access issues. In message passing, data is encapsulated within messages and *moved* from one thread to another, ensuring that at any given time, only one thread has ownership and responsibility for that piece of data.

Why Use Message Passing?

1. Safety and Simplicity: It inherently prevents many common concurrency bugs like data races, deadlocks, and race conditions that arise from shared mutable state. By moving data, it ensures that a piece of data is only ever accessed by one thread at a time.
2. Clearer Communication: The flow of data and control is made explicit through messages, making concurrent programs easier to understand, design, and debug.
3. Decoupling: Threads are more independent and less coupled, as they don't directly manipulate each other's state.
4. Alignment with Ownership (in Rust): Rust's ownership system naturally aligns with message passing. When data is sent through a message, its ownership is *transferred* from the sending thread to the receiving thread. This means the sending thread can no longer access the data after it has been sent, providing strong compile-time guarantees against use-after-move errors and concurrent mutable access.

How Message Passing Works (Conceptual):

At its core, message passing involves:
* Channels: A communication conduit between threads. A channel typically has a sending end (sender) and a receiving end (receiver).
* Sending: A thread places a message into the channel using the sender.
* Receiving: Another thread retrieves a message from the channel using the receiver. This can be blocking (waiting until a message is available) or non-blocking (returning immediately, possibly with an error if no message is present).

Message Passing in Rust:

Rust provides message passing primarily through channels, which are found in the `std::sync::mpsc` module. `mpsc` stands for "Multiple Producer, Single Consumer," meaning that a channel can have multiple sending ends (senders) but only one receiving end (receiver).

Key components:
* `mpsc::channel()`: Creates a new channel, returning a `(Sender<T>, Receiver<T>)` tuple, where `T` is the type of data being sent.
* `Sender<T>`: The sending half of the channel.
* `send(value: T)`: Moves `value` into the channel. Returns `Ok(())` on success or an `Err` if the receiver has been dropped.
* `Receiver<T>`: The receiving half of the channel.
* `recv()`: Blocks the current thread until a message is received. Returns `Ok(T)` with the received value or an `Err` if the sender has been dropped and no more messages are in the channel.
* `try_recv()`: Attempts to receive a message without blocking. Returns `Ok(T)` if a message is available, `Err(mpsc::TryRecvError::Empty)` if no message is available, or `Err(mpsc::TryRecvError::Disconnected)` if the sender has been dropped.
* Iterating directly over a `Receiver` (e.g., `for msg in receiver { ... }`) implicitly calls `recv()` until the channel is closed and empty.

Any data type `T` that implements the `Send` trait can be sent through an `mpsc` channel. The `Send` trait is automatically implemented for most primitive types and many standard library types, indicating that it's safe to transfer ownership of values of that type between threads.

use std::sync::mpsc;
use std::thread;
use std::time::Duration;

fn main() {
    // 1. Create a channel: (sender, receiver) pair
    let (tx, rx) = mpsc::channel();

    // 2. Spawn a sender thread
    // The `move` keyword is used to transfer ownership of `tx` to the new thread.
    let sender_thread_handle = thread::spawn(move || {
        let messages = vec![
            String::from("hi"),
            String::from("from"),
            String::from("the"),
            String::from("sender"),
        ];

        for msg in messages {
            println!("Sender: Sending '{}'", msg);
            // 3. Send messages through the channel.
            // The `send` method takes ownership of `msg`.
            tx.send(msg).unwrap();
            thread::sleep(Duration::from_millis(500)); // Simulate some work
        }
        println!("Sender: Finished sending messages.");
        // When `tx` goes out of scope, the channel is considered 'closed' from this end.
    });

    // 4. In the main thread, receive messages.
    // The `rx` (receiver) can be iterated over directly. This will block
    // until a message is available and stop when the sender closes the channel
    // and all messages have been received.
    println!("Receiver: Waiting for messages...");
    for received_msg in rx {
        println!("Receiver: Got '{}'", received_msg);
    }
    println!("Receiver: All messages received and sender disconnected.");

    // Wait for the sender thread to complete, ensuring all messages are sent
    // before the program exits.
    sender_thread_handle.join().unwrap();

    // --- Example with multiple senders (using `clone()`) ---
    println!("\n--- Multiple Senders Example ---");

    let (tx2, rx2) = mpsc::channel();

    // Create multiple senders by cloning the original transmitter
    let tx3 = mpsc::Sender::clone(&tx2);

    thread::spawn(move || {
        let msgs = vec!["Hello", "from", "sender A"];
        for msg in msgs {
            tx2.send(String::from(msg)).unwrap();
            thread::sleep(Duration::from_millis(300));
        }
    });

    thread::spawn(move || {
        let msgs = vec!["Hi", "from", "sender B"];
        for msg in msgs {
            tx3.send(String::from(msg)).unwrap();
            thread::sleep(Duration::from_millis(500));
        }
    });

    // The receiver will collect messages from both senders
    for received_msg in rx2 {
        println!("Receiver (Multi): Got '{}'", received_msg);
    }
    println!("Receiver (Multi): All messages received and all senders disconnected.");
}