How to Use Arc<Mutex<T>> for Thread-Safe Mutable State

Wrap your data in Arc::new(Mutex::new(value)) to share mutable state safely across threads. Arc allows multiple threads to own the data, while Mutex ensures only one thread modifies it at a time.

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

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

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

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

    println!("Result: {}", *counter.lock().unwrap());
}

Use this pattern when multiple threads need to read and update the same piece of data without crashing. Think of Arc as a shared key that lets everyone enter the room, and Mutex as a single chair that only one person can sit in at a time to write on the whiteboard.