Rust Concurrency

Rust Concurrency Skill

Master thread-based concurrency: threads, channels, synchronization, and parallel processing.

Quick Start

Threads

use std::thread;

let handle = thread::spawn(|| {
    println!("Hello from thread!");
    42
});

let result = handle.join().unwrap();

Channels

use std::sync::mpsc;

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

thread::spawn(move || {
    tx.send("message").unwrap();
});

println!("Got: {}", rx.recv().unwrap());

Mutex

use std::sync::{Arc, Mutex};

let counter = Arc::new(Mutex::new(0));
let mut handles = vec![];

for _ in 0..10 {
    let counter = Arc::clone(&counter);
    handles.push(thread::spawn(move || {
        *counter.lock().unwrap() += 1;
    }));
}

for h in handles { h.join().unwrap(); }

Parallel Iterators (Rayon)

use rayon::prelude::*;

let sum: i32 = (0..1000)
    .into_par_iter()
    .map(|x| x * 2)
    .sum();

Parallel Operations

// Parallel map
let results: Vec<_> = data.par_iter()
    .map(|x| expensive(x))
    .collect();

// Parallel sort
data.par_sort();

Synchronization

RwLock

use std::sync::RwLock;

let data = RwLock::new(vec![]);

// Multiple readers
let read = data.read().unwrap();

// Single writer
let mut write = data.write().unwrap();

Atomics

use std::sync::atomic::{AtomicUsize, Ordering};

let counter = AtomicUsize::new(0);
counter.fetch_add(1, Ordering::SeqCst);

Troubleshooting

Resources

• Rust Book Ch.16
• Rayon