How to Ensure Thread Safety in Rust

Ensure thread safety in Rust by using the compiler's ownership system to prevent data races at compile time, typically by wrapping shared mutable state in std::sync::Mutex or std::sync::RwLock.

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

Rust guarantees thread safety by checking your code before it runs, ensuring no two threads can accidentally mess up shared data at the same time. Think of it like a strict librarian who only lets one person edit a book at a time, locking the book for everyone else until that person is done. You use special containers like Mutex to enforce this rule automatically.