Arc

Arc allows shared read-only access via Arc::clone:

  1. use std::sync::Arc;
  2. use std::thread;
  4. fn main() {
  5.     let v = Arc::new(vec![10, 20, 30]);
  6.     let mut handles = Vec::new();
  7.     for _ in 0..5 {
  8.         let v = Arc::clone(&v);
  9.         handles.push(thread::spawn(move || {
  10.             let thread_id = thread::current().id();
  11.             println!("{thread_id:?}: {v:?}");
  12.         }));
  13.     }
  15.     handles.into_iter().for_each(|h| h.join().unwrap());
  16.     println!("v: {v:?}");
  17. }

This slide should take about 5 minutes.

  • Arc stands for “Atomic Reference Counted”, a thread safe version of Rc that uses atomic operations.
  • Arc<T> implements Clone whether or not T does. It implements Send and Sync if and only if T implements them both.
  • Arc::clone() has the cost of atomic operations that get executed, but after that the use of the T is free.
  • Beware of reference cycles, Arc does not use a garbage collector to detect them.
    • std::sync::Weak can help.