Rust: What is the difference between Rc and Arc?

Both Rc and Arc provide shared ownership through reference counting, but Rc uses non-atomic operations (single-thread only, faster) while Arc uses atomic operations (thread-safe, slightly slower).

Rc — non-atomic reference counting:

• Simple increment/decrement — no memory barriers.
• Very fast: ~1-2 ns per clone.
• Does NOT implement Send or Sync traits.
• Compiler rejects any attempt to move Rc across threads.

1use std::rc::Rc;
2
3let data = Rc::new(vec![1, 2, 3]);
4let shared = Rc::clone(&data);
5println!("Refs: {}", Rc::strong_count(&data));  // 2
6
7// This won't compile:
8// std::thread::spawn(move || println!("{:?}", shared));

Arc — atomic reference counting:

• Uses atomic CAS (compare-and-swap) with memory ordering.
• Slower: ~5-15 ns per clone.
• Implements Send + Sync — safe to share across threads.
• Required whenever data crosses thread boundaries.

1use std::sync::Arc;
2use std::thread;
3
4let data = Arc::new(vec![1, 2, 3]);
5let mut handles = vec![];
6
7for i in 0..3 {
8    let data = Arc::clone(&data);
9    handles.push(thread::spawn(move || {
10        println!("Thread {}: {:?}", i, *data);
11    }));
12}
13
14for h in handles {
15    h.join().unwrap();
16}

When to use Rc:

• Single-threaded shared ownership.
• Performance-critical code in one thread.
• Simple shared data structures (trees, linked lists).

When to use Arc:

• Multi-threaded applications.
• Shared state in concurrent servers.
• Read-only data shared between workers.

Common mistakes:

• Using Rc in multi-threaded code (compile error).
• Using Arc when Rc suffices — paying atomic overhead for no reason.
• Assuming Arc makes the inner data thread-safe — it only makes the pointer safe. Wrap in Mutex/RwLock for mutable shared data.