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(vec!["task1", "task2"]);
4let worker1 = Rc::clone(&shared);
5let worker2 = Rc::clone(&shared);
6
7println!("Worker1: {:?}", *worker1);
8println!("Worker2: {:?}", *worker2);
9println!("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 tasks = Arc::new(vec!["task1", "task2", "task3"]);
5let mut handles = vec![];
6
7for i in 0..3 {
8    let t = Arc::clone(&tasks);
9    handles.push(thread::spawn(move || {
10        for task in t.iter() {
11            println!("Thread {}: {}", i, task);
12        }
13    }));
14}
15for 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.