What is a mutex in Rust and how do I use it?

What is a mutex in Rust and how do I use it?

A mutex, or mutual exclusion, is a synchronization primitive used to manage access to shared data in concurrent programming. In Rust, you can use the std::sync::Mutex type to create a mutex.

Can you show me a simple example of using a mutex in Rust?

Sure! Here's a basic example:

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

This code creates a mutex-protected counter that is incremented by multiple threads.

What happens if I try to lock a mutex that is already locked?

If you try to lock a mutex that is already locked by another thread, your thread will block until the mutex becomes available. This ensures that only one thread can access the protected data at a time.

Are there any alternatives to mutexes in Rust?

Yes, alternatives include RwLock for read-write access and Atomic types for lock-free concurrency. Each has its use cases depending on your needs.