Rust: What is the difference between Rc and Arc?

Rc = reference counted, single-threaded, non-atomic. Arc = atomic reference counted, multi-threaded, atomic. Same shared-ownership concept, different thread-safety.

Rc — fast, single-thread:

• Non-atomic increment/decrement.
• Does NOT implement Send/Sync.
• Compiler prevents cross-thread use.
• Fastest shared ownership.

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

Arc — safe, multi-threaded:

• Atomic increment/decrement.
• Implements Send + Sync.
• Required for cross-thread sharing.
• Essential for concurrent code.

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        println!("Thread {}: {:?}", i, *d);
11    }));
12}
13for 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 unnecessarily.
• Forgetting Mutex/RwLock for mutable shared data.