Snippet

Thread-Based Concurrency with std::thread and Channels

Rust's std::thread module enables native OS thread creation, and mpsc (multi-producer, single-consumer) channels provide safe communication between threads. The channel consists of a transmitter (tx) and receiver (rx). The spawn function creates a new thread, and move allows the closure to take ownership of captured variables (tx in this case). Messages sent through the channel are guaranteed to be delivered without data races. The receiver iterator blocks until messages are available, making it ideal for coordinating between threads. This approach to concurrency is explicit and type-safe - the compiler ensures no messages are lost due to type mismatches.

snippet.rs

rust

use std::thread;
use std::sync::mpsc;
use std::time::Duration;
 
fn main() {
    let (tx, rx) = mpsc::channel();
 
    let handle = thread::spawn(move || {
        for i in 1..=5 {
            println!("Thread: sending {}", i);
            tx.send(i).unwrap();
            thread::sleep(Duration::from_millis(100));
        }
    });
 
    for received in rx.iter().take(5) {
        println!("Main: received {}", received);
    }
 
    handle.join().unwrap();
    println!("Thread completed successfully");
}

Breakdown

use std::thread;

Import thread module for spawning native OS threads

use std::sync::mpsc;

Import mpsc (multi-producer single-consumer) channel primitives

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

Create a channel pair: transmitter and receiver endpoints

let handle = thread::spawn(move || {

Spawn new thread, move transfers tx ownership into the closure

for i in 1..=5 {

Loop 5 times sending incrementing integers

tx.send(i).unwrap();

Send value through channel, unwrap handles send errors

thread::sleep(Duration::from_millis(100));

Simulate work with 100ms pause between sends

for received in rx.iter().take(5) {

Iterate over channel with take(5) to process exactly 5 messages

println!("Main: received {}", received);

Print each received value in the main thread

handle.join().unwrap();

Wait for spawned thread to complete, unwrap join result

println!("Thread completed successfully");

Confirmation message after thread finishes

Previous snippet Next snippet

More Intermediate Rust exercises →

Thread-Based Concurrency with std::thread and Channels

Related