How to Use Arc<Mutex<T>> Pattern in Rust

Use Arc<Mutex<T>> to share mutable state safely across multiple threads by wrapping the data in a Mutex for synchronization and an Arc for reference counting.

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());
}

The Arc<Mutex> pattern lets multiple threads safely update the same piece of data at the same time. Think of Mutex as a single key to a room that only one person can hold at a time, and Arc as a way to make copies of that key so everyone has access to the room. You use it when you need shared, changing data in a multi-threaded program.