Message Passing

📬 Message Passing in Rust: The Postal Service of Concurrency

Imagine a busy post office where letters fly between workers. That’s how Rust threads talk to each other!

🎯 The Big Idea

In Rust, threads don’t share memory directly (that’s dangerous!). Instead, they send messages to each other — like passing notes in class, but much safer!

Our Everyday Analogy: Think of a post office.

• Workers (threads) can’t just grab things from each other’s desks
• Instead, they put letters in a mailbox (channel)
• Someone else picks up the mail from the other end

This is called Message Passing, and Rust makes it super easy!

📮 What is a Channel?

A channel is like a tube that connects two ends:

• One end sends messages (the sender)
• One end receives messages (the receiver)

// Create a channel
let (sender, receiver) = mpsc::channel();

Think of it like a water slide:

• You drop a ball at the top (send)
• It comes out at the bottom (receive)
• The ball travels one way only!

🔧 The mpsc Module

mpsc stands for Multiple Producers, Single Consumer.

What does that mean?

• Multiple Producers: Many threads can SEND messages
• Single Consumer: Only ONE thread RECEIVES them

use std::sync::mpsc;

Real Life Example:

• Many customers (producers) drop letters in a mailbox
• One mail carrier (consumer) collects them all

graph TD
    A["Thread 1 - Sender"] -->|message| D["Channel"]
    B["Thread 2 - Sender"] -->|message| D
    C["Thread 3 - Sender"] -->|message| D
    D -->|all messages| E["Main Thread - Receiver"]

📤 Sender and Receiver

When you create a channel, you get two pieces:

The Sender (tx)

• Used to send messages into the channel
• Can be cloned to create multiple senders
• Like having multiple people who can drop mail

use std::sync::mpsc;
use std::thread;

let (tx, rx) = mpsc::channel();

// Send from another thread
thread::spawn(move || {
    tx.send("Hello!").unwrap();
});

The Receiver (rx)

• Used to receive messages from the channel
• Cannot be cloned (only one receiver!)
• Like having one person at the post office

// Receive in main thread
let message = rx.recv().unwrap();
println!("Got: {}", message);

📊 Quick Comparison

🎭 A Simple Story

Let’s see a complete example:

use std::sync::mpsc;
use std::thread;

fn main() {
    // Create our postal tube
    let (tx, rx) = mpsc::channel();

    // Spawn a helper thread
    thread::spawn(move || {
        let message = "Hi from thread!";
        tx.send(message).unwrap();
        println!("Message sent!");
    });

    // Wait for the message
    let received = rx.recv().unwrap();
    println!("Got: {}", received);
}

What happens:

1. We create a channel (tx and rx)
2. A new thread takes the sender (tx)
3. That thread sends “Hi from thread!”
4. Main thread waits and receives it

👥 Multiple Producers

Remember: mpsc means multiple producers!

You can have MANY senders but only ONE receiver:

use std::sync::mpsc;
use std::thread;

fn main() {
    let (tx, rx) = mpsc::channel();

    // Clone the sender for each thread
    let tx1 = tx.clone();
    let tx2 = tx.clone();

    thread::spawn(move || {
        tx1.send("From thread 1").unwrap();
    });

    thread::spawn(move || {
        tx2.send("From thread 2").unwrap();
    });

    // Don't forget the original sender!
    drop(tx);

    // Receive ALL messages
    for msg in rx {
        println!("Got: {}", msg);
    }
}

Key Points:

• Use .clone() to make copies of sender
• Each thread gets its own sender copy
• drop(tx) closes original sender
• The loop ends when ALL senders are dropped

graph TD
    A["tx1 - Thread 1"] -->|"From thread 1"| D["Channel rx"]
    B["tx2 - Thread 2"] -->|"From thread 2"| D
    D -->|iterate| E["Main Thread"]
    E -->|prints| F["Got: From thread 1"]
    E -->|prints| G["Got: From thread 2"]

🎯 Receiving Methods

There are different ways to receive messages:

recv() - Wait Forever

let msg = rx.recv().unwrap();
// Blocks until a message arrives

try_recv() - Check Immediately

match rx.try_recv() {
    Ok(msg) => println!("Got: {}", msg),
    Err(_) => println!("Nothing yet!"),
}
// Doesn't wait - returns immediately

recv_timeout() - Wait a Bit

use std::time::Duration;

match rx.recv_timeout(Duration::from_secs(2)) {
    Ok(msg) => println!("Got: {}", msg),
    Err(_) => println!("Timed out!"),
}
// Waits up to 2 seconds

🌟 Why Message Passing?

Rust’s motto: “Do not communicate by sharing memory; instead, share memory by communicating.”

💡 Pro Tips

1. Ownership Moves: When you send a value, you give it away!

let s = String::from("hello");
tx.send(s).unwrap();
// Can't use 's' anymore - it moved!

2. Clone Before Spawn: Always clone the sender BEFORE moving it into a thread

3. Drop Original Sender: If you clone senders, drop the original so the receiver knows when everyone is done

4. Iterator Magic: Use for msg in rx to receive until all senders are gone

🎉 Summary

You’ve learned how Rust threads talk safely — through channels! 🎊

No shared memory, no data races, just clean message passing. That’s the Rust way!

Next up: Try the interactive simulation to see channels in action!