Rust: What is the difference between Rc and Arc?

Rc (Reference Counted) provides multiple ownership through non-atomic reference counting and is NOT thread-safe. Arc (Atomic Reference Counted) provides multiple ownership through atomic reference counting and IS thread-safe.

Rc — single-threaded:

• Uses non-atomic operations for incrementing/decrementing the reference count.
• Faster than Arc because atomic operations have overhead.
• Cannot be shared across thread boundaries (does not implement Send or Sync).
• Perfect for single-threaded shared ownership scenarios.

1use std::rc::Rc;
2
3let data = Rc::new(String::from("hello"));
4let data2 = Rc::clone(&data);
5println!("Count: {}", Rc::strong_count(&data));  // 2
6// Will NOT compile if sent to another thread

Arc — multi-threaded:

• Uses atomic operations (compare-and-swap) for reference count management.
• Slightly slower than Rc due to atomic overhead.
• Implements Send and Sync — safe to share across threads.
• Essential for concurrent data sharing.

1use std::sync::Arc;
2use std::thread;
3
4let data = Arc::new(vec![1, 2, 3]);
5
6for i in 0..3 {
7    let data_clone = Arc::clone(&data);
8    thread::spawn(move || {
9        println!("Thread {}: {:?}", i, data_clone);
10    });
11}
12// All threads can safely read the same data

When to use Rc:

• Single-threaded applications with shared ownership.
• Performance-critical code where atomic overhead matters.
• Graph structures, trees, or shared caches in one thread.

When to use Arc:

• Multi-threaded applications needing shared data.
• Concurrent servers, thread pools, or parallel processing.
• When you need shared ownership AND thread safety.

Common mistakes:

• Using Rc in a multi-threaded context (compile error: Rc is not Send).
• Using Arc in single-threaded code when Rc would be faster.
• Forgetting that Arc only makes the pointer thread-safe, not the inner data — wrap in Mutex/RwLock for mutable shared data.