Rust: What is the difference between Rc and Arc?

Rc = reference counted, single-threaded, uses non-atomic operations. Arc = atomic reference counted, multi-threaded, uses atomic operations. Same API, different thread-safety guarantees.

Rc — fast, single-thread:

• Non-atomic increment/decrement.
• ~1-2 ns per clone.
• Does NOT implement Send or Sync.
• Compiler enforces single-thread usage.

1use std::rc::Rc;
2
3let config = Rc::new(vec!["debug", "verbose"]);
4let reader1 = Rc::clone(&config);
5let reader2 = Rc::clone(&config);
6
7// All in the same thread
8println!("{}", reader1.len());  // 2
9println!("{}", reader2.len());  // 2

Arc — safe, multi-thread:

• Atomic increment/decrement.
• ~5-15 ns per clone.
• Implements Send + Sync.
• Required for cross-thread sharing.

1use std::sync::Arc;
2use std::thread;
3
4let data = Arc::new(vec![1, 2, 3, 4, 5]);
5let mut handles = vec![];
6
7for chunk_size in [1, 2, 5] {
8    let d = Arc::clone(&data);
9    handles.push(thread::spawn(move || {
10        println!("Chunk {}: {:?}", chunk_size,
11            d.chunks(chunk_size).collect::<Vec<_>>());
12    }));
13}
14
15for h in handles {
16    h.join().unwrap();
17}

When to use Rc:

• Single-threaded shared ownership.
• Performance-sensitive code.
• Simple shared data structures.

When to use Arc:

• Multi-threaded applications.
• Shared state in concurrent code.
• When data crosses thread boundaries.

Common mistakes:

• Using Rc in multi-threaded code.
• Using Arc when Rc suffices.
• Assuming Arc makes inner data thread-safe.