Rust: What is the difference between Rc and Arc?

Rc = reference counted, NOT thread-safe, uses non-atomic ops. Arc = atomic reference counted, thread-safe, uses atomic ops. Same concept, different thread-safety level.

Rc — fast, single-thread only:

• Non-atomic increment/decrement.
• Fastest option for shared ownership.
• Does NOT implement Send/Sync.
• Compiler prevents thread sharing.

1use std::rc::Rc;
2
3let data = Rc::new(42);
4let ref1 = Rc::clone(&data);
5let ref2 = Rc::clone(&data);
6println!("{}", *ref1 + *ref2);  // 84

Arc — safe, multi-threaded:

• Atomic increment/decrement.
• Thread-safe via Send + Sync.
• Slightly slower than Rc.
• Required for concurrent code.

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 d = Arc::clone(&data);
9    handles.push(thread::spawn(move || {
10        println!("Thread {}: sum={}", i, d.iter().sum::<i32>());
11    }));
12}
13
14for h in handles { h.join().unwrap(); }

When to use Rc:

• Single-threaded code.
• Performance-critical paths.
• 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 in single-threaded code.
• Forgetting Mutex/RwLock for mutable shared data.