Threads

Why threads?

Modern computers have several CPU cores. A program with one thread uses only one core at a time. Concurrency means several tasks make progress during the same period; parallelism means they literally run at the same instant on different cores. Threads give you both. They are useful for CPU-heavy work, such as resizing thousands of photos or calculating reports for every branch of a bank.

Concurrency is famous for hard bugs: data races, where two threads touch the same data at once and at least one writes. Rust's ownership and borrowing rules extend to threads, so most of these bugs become compile errors. Rust calls this "fearless concurrency".

Spawning and joining

use std::thread;
use std::time::Duration;

fn main() {
    let handle = thread::spawn(|| {
        for i in 1..=3 {
            println!("worker: step {i}");
            thread::sleep(Duration::from_millis(10));
        }
    });

    println!("main: doing other work");
    handle.join().unwrap();      // wait for the worker to finish
    println!("main: all done");
}

spawn takes a closure and runs it on a new thread. It returns a JoinHandle. join() blocks (waits) until that thread ends and returns a Result: Err if the thread panicked. If main ends first, the whole program exits and other threads are stopped, so always join threads whose work matters.

Why move is needed

let city = String::from("Chennai");
let h = thread::spawn(|| {
    println!("{city}");
});
// error[E0373]: closure may outlive the current function, but it borrows `city`
// help: to force the closure to take ownership of `city`, use the `move` keyword

let city = String::from("Chennai");
let h = thread::spawn(move || {
    println!("{city}");          // the thread now owns city
});
h.join().unwrap();

Returning results from threads

let handles: Vec<_> = (1..=4)
    .map(|branch| thread::spawn(move || branch * 1000))   // pretend calculation
    .collect();

let total: u32 = handles.into_iter().map(|h| h.join().unwrap()).sum();
println!("{total}");   // 10000

Scoped threads: borrowing safely

std::thread::scope (stable since Rust 1.63) creates a scope in which you spawn threads that are guaranteed to finish before the scope ends. Because of that guarantee, they may borrow local variables without move.

use std::thread;

fn main() {
    let sales = vec![1200, 450, 3000, 800];
    let (left, right) = sales.split_at(2);
    let (a, b) = thread::scope(|s| {
        let h1 = s.spawn(|| left.iter().sum::<u32>());
        let h2 = s.spawn(|| right.iter().sum::<u32>());
        (h1.join().unwrap(), h2.join().unwrap())
    });
    println!("{}", a + b);   // 5450
    println!("{:?}", sales); // still usable: only borrowed
}

The operating system decides which thread runs when. This is called scheduling, and it is not predictable: the same program can print lines in a different order on each run. Never rely on threads running in a particular order; if order matters, use join, channels or locks to coordinate.

Common mistakes

• Forgetting join, so main exits before the work is done.
• Spawning a thread per tiny task. Threads cost memory (each has its own stack) and time to start. For many small jobs use a pool (for example the rayon crate) or async.
• Expecting output in a fixed order. Threads are scheduled by the operating system.
• Ignoring the Result of join: a panicking worker should be noticed.