Rust: What is the difference between Rc and Arc?

Rc = reference counted, NOT thread-safe, non-atomic. Arc = atomic reference counted, thread-safe, atomic operations. Same shared-ownership concept, different thread-safety levels.

Rc — fast, single-thread:

• Non-atomic operations (fast).
• Does NOT implement Send or Sync.
• Compiler prevents cross-thread use.
• Ideal for single-threaded shared data.

1use std::rc::Rc;
2
3let shared = Rc::new(String::from("cached"));
4let a = Rc::clone(&shared);
5let b = Rc::clone(&shared);
6println!("{} {} {}", *shared, *a, *b);  // cached cached cached
7println!("Count: {}", Rc::strong_count(&shared));  // 3

Arc — safe, multi-thread:

• Atomic operations (slower but safe).
• Implements Send + Sync.
• Required for cross-thread data sharing.
• Essential for concurrent programs.

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

When to use Rc:

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

When to use Arc:

• Multi-threaded applications.
• Concurrent data sharing.
• Cross-thread data access.

Common mistakes:

• Using Rc in multi-threaded code.
• Using Arc in single-threaded code unnecessarily.
• Forgetting Mutex/RwLock for mutable shared data.