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 pattern, different thread-safety.

Rc — fast, single-thread only:

• Non-atomic operations.
• Does NOT implement Send/Sync.
• Compiler prevents thread sharing.
• Fastest shared ownership.

1use std::rc::Rc;
2
3let config = Rc::new(vec!["opt1", "opt2"]);
4let handler = Rc::clone(&config);
5println!("Options: {:?}", *handler);  // ["opt1", "opt2"]
6println!("Count: {}", Rc::strong_count(&config));  // 2

Arc — safe, multi-threaded:

• Atomic operations.
• 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..4 {
8    let d = Arc::clone(&data);
9    handles.push(thread::spawn(move || {
10        let max = d.iter().max().unwrap();
11        println!("Thread {}: max={}", i, max);
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 unnecessarily.
• Forgetting Mutex/RwLock for mutable shared data.