Threads, ownership and joining

A school tool can compute a subtotal on a worker thread while main coordinates the report. A thread is an independently scheduled execution path. Ownership determines what data the worker may keep, while joining waits for it to finish and retrieves its result.

thread::spawn accepts a closure that may outlive the calling scope. A move closure transfers the captured vector into the worker. join returns a Result because the worker may panic. The example prints only after joining, so its displayed order does not depend on which thread the scheduler runs first.

Connect this idea with ownership, moves and cleanup and channels, arc and mutex.

Save the complete source as main.rs in the Rust environment. No standard input is needed.

Rust 2024 · complete program

use std::thread;
fn main() {
  let marks = vec![70, 80, 90];
  let worker = thread::spawn(move || marks.into_iter().sum::<i32>());
  let total = worker.join().expect("worker should complete");
  println!("Total: {total}");
}

Expected output

Total: 240

Follow the execution

The worker owns the vector and sums it to 240. Main waits at join before receiving that integer and printing it. Main cannot reuse the moved marks binding; it can use the returned total.

Try the complete program in the Rust compiler. For tests, Cargo commands and local files, use the specified local environment.

Your task: Why is the final print after join important?

Rust 2024 · complete program

use std::thread;
fn main() {
  let marks = vec![70, 80, 90];
  let worker = thread::spawn(move || marks.into_iter().sum::<i32>());
  let total = worker.join().expect("worker should complete");
  println!("Total: {total}");
}

Worked answer

It waits until the worker has produced the result. Starting a thread alone does not guarantee it has completed before the next instruction in main.

Thread creation has overhead and does not guarantee a speedup. Scoped threads can borrow suitable data while the scope ensures they finish. A panic in a worker is reported through join; real applications should choose a recovery policy rather than automatically expecting success.

It waits until the worker has produced the result. Starting a thread alone does not guarantee it has completed before the next instruction in main. Thread creation has overhead and does not guarantee a speedup.

Further reading: the official Rust Book on threads, ownership and joining.