OS Threads, JoinHandle Panic Isolation & Shared-State Concurrency

Modern processors achieve high throughput through multi-core parallel execution. Rust provides direct access to native operating system threads via std::thread::spawn.

Unlike traditional languages where multi-threading is plagued by race conditions and undefined behavior, Rust's type system statically verifies thread boundaries at compile time.

1. Thread Spawning & Closure Boundaries#

When spawning a thread, the operating system allocates a dedicated hardware stack (typically 2 MB by default). Because the spawned thread may outlive the caller stack frame, the closure passed to thread::spawn must satisfy two strict compile-time bounds:

The 'static lifetime bound prevents spawned threads from capturing borrowed references from the parent stack that might be deallocated while the child is still executing.

2. JoinHandle & Panic Isolation#

When a thread is spawned, thread::spawn returns a JoinHandle<R>. Calling .join() blocks the parent thread until the child thread finishes, yielding its computation result:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
use std::thread;

fn main() {
    let handle = thread::spawn(|| {
        println!("Child thread running on independent OS core");
        42 // Return value
    });

    // Parent waits for child completion:
    match handle.join() {
        Ok(value) => println!("Child thread returned: {}", value),
        Err(e) => eprintln!("Child thread panicked! {:?}", e),
    }
}

Panic Fault Isolation#

If a child thread panics, the panic is strictly isolated to the child's stack frame. It does not crash the parent thread. Instead, the panic payload is captured and delivered inside the Err variant of handle.join().

3. Shared Mutable State: The Arc<Mutex<T>> Pattern#

To share mutable data across multiple threads, you combine two primitives:

1. Arc<T> (Atomic Reference Counting): Allows multiple threads to own shared handles to the same heap allocation.
2. Mutex<T> (Mutual Exclusion Lock): Guarantees that only one thread can access or mutate the inner value at any single instant.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
use std::sync::{Arc, Mutex};
use std::thread;

fn main() {
    // Wrap counter in Arc and Mutex:
    let counter = Arc::new(Mutex::new(0));
    let mut handles = vec![];

    for _ in 0..10 {
        let counter_clone = Arc::clone(&counter);
        let handle = thread::spawn(move || {
            // lock() blocks until this thread acquires exclusive access.
            // Returns a MutexGuard implementing DerefMut and Drop.
            let mut num = counter_clone.lock().unwrap();
            *num += 1;
            // Lock is automatically released here when MutexGuard is dropped!
        });
        handles.push(handle);
    }

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

    println!("Final count: {}", *counter.lock().unwrap()); // Exactly 10!
}

4. Concept Verification#

Test your understanding of native threads and shared state: