Rust: What is the difference between Rc and Arc?

Rc and Arc both provide shared ownership through reference counting, but Rc is single-threaded (uses non-atomic operations) while Arc is multi-threaded (uses atomic operations for thread safety).

Rc — single-threaded reference counting:

• Increments/decrements count using regular (non-atomic) memory operations.
• Faster because no CPU cache-line invalidation.
• Cannot be sent across thread boundaries (does not implement Send).
• Cannot be shared between threads (does not implement Sync).

1use std::rc::Rc;
2
3let data = Rc::new(vec![1, 2, 3]);
4let clone1 = Rc::clone(&data);
5let clone2 = Rc::clone(&data);
6println!("Strong count: {}", Rc::strong_count(&data));  // 3
7// This would NOT compile:
8// std::thread::spawn(move || println!("{:?}", data));

Arc — atomic reference counting:

• Uses atomic compare-and-swap operations for count management.
• Slightly slower due to memory ordering guarantees.
• Implements Send + Sync — safe across threads.
• Essential for concurrent Rust programs.

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

Performance comparison:

• Rc::clone: ~1-2 ns (non-atomic increment).
• Arc::clone: ~5-15 ns (atomic increment with memory fence).
• The difference matters in tight loops but is negligible in most applications.

When to use Rc:

• Single-threaded shared ownership (most common).
• Performance-sensitive code where atomic overhead is measured.
• Non-concurrent data structures.

When to use Arc:

• Multi-threaded code sharing read-only data.
• Concurrent servers or worker pools.
• Anytime shared data crosses thread boundaries.

Common mistakes:

• Using Rc in multi-threaded code (compiler error: Rc<i32> cannot be sent between threads safely).
• Using Arc in single-threaded code unnecessarily.
• Forgetting that Arc only makes the pointer thread-safe — the inner data may need Mutex/RwLock for mutation.