Mutex

Mutex ensures mutual exclusion and allows mutable access to T behind a read-only interface (another form of interior mutability):

  1. use std::sync::Mutex;
  3. fn main() {
  4.     let v = Mutex::new(vec![10, 20, 30]);
  5.     println!("v: {:?}", v.lock().unwrap());
  7.     {
  8.         let mut guard = v.lock().unwrap();
  9.         guard.push(40);
  10.     }
  12.     println!("v: {:?}", v.lock().unwrap());
  13. }

Notice how we have a impl Sync for Mutex blanket implementation.

This slide should take about 14 minutes.

  • Mutex in Rust looks like a collection with just one element —- the protected data.
    • It is not possible to forget to acquire the mutex before accessing the protected data.
  • You can get an &mut T from an &Mutex<T> by taking the lock. The MutexGuard ensures that the &mut T doesn’t outlive the lock being held.
  • Mutex<T> implements both Send and Sync if and only if T implements Send.
  • A read-write lock counterpart: RwLock.
  • Why does lock() return a Result?
    • If the thread that held the Mutex panicked, the Mutex becomes “poisoned” to signal that the data it protected might be in an inconsistent state. Calling lock() on a poisoned mutex fails with a PoisonError. You can call into_inner() on the error to recover the data regardless.