Message passing with channels

Sharing by communicating

There are two main ways for threads to cooperate: share memory with locks (next topic), or send messages. Many developers find messages easier to reason about: each piece of data belongs to one thread at a time, and moves to another thread by being sent. A channel is the pipe that carries these messages.

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

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

    thread::spawn(move || {
        let order = String::from("2 masala chai");
        tx.send(order).unwrap();
        // println!("{order}");   // error: borrow of moved value: order
    });

    let received = rx.recv().unwrap();   // waits until a message arrives
    println!("kitchen got: {received}");
}

recv() blocks until a message arrives. It returns Err when all senders have been dropped and the channel is empty, meaning no more messages can ever come. try_recv() does not wait: it returns immediately with a message or an error.

Notice that the channel is typed. mpsc::channel() creates a Sender<T> and a Receiver<T> for one type T, which Rust usually infers from the first send. You cannot send a String on one line and a number on the next; if you need different kinds of messages, send an enum with one variant per kind.

Several producers

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

fn main() {
    let (tx, rx) = mpsc::channel();
    for waiter in 1..=3 {
        let tx = tx.clone();                 // each thread gets its own Sender
        thread::spawn(move || {
            tx.send(format!("order from waiter {waiter}")).unwrap();
        });
    }
    drop(tx);                                // drop the original Sender

    for msg in rx {                          // ends when all Senders are gone
        println!("{msg}");
    }
}

What the types say

mpsc::channel() is unbounded: it can grow without limit if the consumer is slower than the producers. sync_channel(n) adds back-pressure: producers wait when the queue is full, which protects memory. For multiple consumers, crates such as crossbeam-channel provide more channel types; async code uses tokio's channels.

Common mistakes

• A program that never ends: a Sender is still alive (often the original tx in main). Drop it.
• Trying to clone the Receiver. mpsc has one consumer; use a different design or another crate for many consumers.
• Using a value after sending it: send moves it. Send a clone if you still need it.
• Unbounded queues growing without limit under load. Use sync_channel for back-pressure.