CodeUtility
Making your developer's life easier!
Important Rust Topics

Rust Threads: spawn and join

Run code in parallel with thread::spawn and collect each result with join.

  • Advanced
  • 2 min read
  • 1 runnable example
What you'll learn
  • thread::spawn
  • move closures
  • join and return values
Run code →
Three workers
  1. 1spawn x3threads start
  2. 2sumeach works alone
  3. 3join()wait for each
  4. 4resultsprinted in order

Work that runs at the same time

A thread runs a piece of code at the same time as the rest of the program. thread::spawn starts one and returns a handle that you can use to wait for it.

move gives each thread its own copy of id. The threads may finish in any order, but join waits for each handle in the order they were created, so the output is always the same. join returns the value the closure produced.

Key points

  1. spawn starts a thread and returns a handle.
  2. move gives the thread its own data.
  3. join waits and returns the thread's value.

Runnable Rust example

Rust
Run code →
main.rs
use std::thread;

fn main() {
    let mut handles = Vec::new();

    for id in 1..=3u64 {
        let handle = thread::spawn(move || {
            let total: u64 = (1..=id * 1000).sum();
            (id, total)
        });
        handles.push(handle);
    }

    for handle in handles {
        let (id, total) = handle.join().unwrap();
        println!("worker {id} summed to {total}");
    }
}
Get a Run button for this example Result of running the code
worker 1 summed to 500500
worker 2 summed to 2001000
worker 3 summed to 4501500

Practice

Open the example in the online compiler, change a value or add a line, and predict the output before you run it. Then break the code on purpose and read the compiler's message.

Finished this lesson?

Mark it as learned to track your progress.

Next: Channels →

Practice with a challenge

Use what this lesson covers to solve a real problem. Each challenge runs in your browser with instant tests and an AI review.

All challenges