Example

Let us see Arc and Mutex in action:

  1. use std::thread;
  2. // use std::sync::{Arc, Mutex};
  4. fn main() {
  5.     let v = vec![10, 20, 30];
  6.     let handle = thread::spawn(|| {
  7.         v.push(10);
  8.     });
  9.     v.push(1000);
  11.     handle.join().unwrap();
  12.     println!("v: {v:?}");
  13. }

This slide should take about 8 minutes.

Possible solution:

  1. use std::sync::{Arc, Mutex};
  2. use std::thread;
  4. fn main() {
  5.     let v = Arc::new(Mutex::new(vec![10, 20, 30]));
  7.     let v2 = Arc::clone(&v);
  8.     let handle = thread::spawn(move || {
  9.         let mut v2 = v2.lock().unwrap();
  10.         v2.push(10);
  11.     });
  13.     {
  14.         let mut v = v.lock().unwrap();
  15.         v.push(1000);
  16.     }
  18.     handle.join().unwrap();
  20.     println!("v: {v:?}");
  21. }

Notable parts:

  • v is wrapped in both Arc and Mutex, because their concerns are orthogonal.
    • Wrapping a Mutex in an Arc is a common pattern to share mutable state between threads.
  • v: Arc<_> needs to be cloned as v2 before it can be moved into another thread. Note move was added to the lambda signature.
  • Blocks are introduced to narrow the scope of the LockGuard as much as possible.