mpsc channel

Create a channel with std::sync::mpsc.

The mpsc channel

Channels let threads communicate by messages instead of sharing data: "Don't communicate by sharing memory; share memory by communicating." mpsc (multiple producer, single consumer) gives a sender (tx) and a receiver (rx):

use std::sync::mpsc;

let (tx, rx) = mpsc::channel();
thread::spawn(move || {
    for i in 1..=3 {
        tx.send(format!("mesaj {i}")).unwrap();
    }
});
for m in rx {                // the loop ends when tx is dropped
    println!("{m}");
}

Ownership of the sent value passes to the receiver; the sender can no longer access it.

A channel is an iterator

for m in rx (or rx.iter()) calls recv for each message and ends when all senders are dropped. When the sender thread's closure finishes, tx is dropped automatically, so the loop ends on its own.

// message order is preserved for a single sender
// mesaj 1
// mesaj 2
// mesaj 3

Exercise Messages

Open a channel. Let a separate thread send the texts mesaj 1, mesaj 2 and mesaj 3; let the main thread print each with for m in rx.

Show example solution

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

fn main() {
    let (tx, rx) = mpsc::channel();
    thread::spawn(move || {
        for i in 1..=3 {
            tx.send(format!("mesaj {i}")).unwrap();
        }
    });
    for m in rx {
        println!("{}", m);
    }
}

Test yourself

What happens if you try to use the value after sending (<code>tx.send(s); println!("{s}")</code>)?
- It works
- Panic
- It prints empty text
- E0382: s was moved into the channel
Show answer

E0382: s was moved into the channel — The transfer of ownership makes it impossible for two threads to change the same data at once.

Open a channel

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

Show answer

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

Piece and role

tx

Sender
rx

Receiver
tx.send(v)

Transfers ownership
for m in rx

Until the senders close

Next lesson: send and recv

We Are Enhancing Your Experience

Cookie Preferences

Strictly Necessary Cookies

Analytical Cookies