Channels

Rust provides asynchronous channels for communication between threads. Channels
allow a unidirectional flow of information between two end-points: the
Sender and the Receiver.

  1. use std::sync::mpsc::{Sender, Receiver};
  2. use std::sync::mpsc;
  3. use std::thread;
  5. static NTHREADS: i32 = 3;
  7. fn main() {
  8.     // Channels have two endpoints: the `Sender<T>` and the `Receiver<T>`,
  9.     // where `T` is the type of the message to be transferred
  10.     // (type annotation is superfluous)
  11.     let (tx, rx): (Sender<i32>, Receiver<i32>) = mpsc::channel();
  13.     for id in 0..NTHREADS {
  14.         // The sender endpoint can be copied
  15.         let thread_tx = tx.clone();
  17.         // Each thread will send its id via the channel
  18.         thread::spawn(move || {
  19.             // The thread takes ownership over `thread_tx`
  20.             // Each thread queues a message in the channel
  21.             thread_tx.send(id).unwrap();
  23.             // Sending is a non-blocking operation, the thread will continue
  24.             // immediately after sending its message
  25.             println!("thread {} finished", id);
  26.         });
  27.     }
  29.     // Here, all the messages are collected
  30.     let mut ids = Vec::with_capacity(NTHREADS as usize);
  31.     for _ in 0..NTHREADS {
  32.         // The `recv` method picks a message from the channel
  33.         // `recv` will block the current thread if there are no messages available
  34.         ids.push(rx.recv());
  35.     }
  37.     // Show the order in which the messages were sent
  38.     println!("{:?}", ids);
  39. }