Rust: What is the difference between Rc and Arc?

Rc and Arc both enable shared ownership via reference counting, but Rc is non-atomic (single-thread, faster) while Arc is atomic (multi-thread, thread-safe).

Rc — non-atomic, single-thread:

• Uses simple increment/decrement operations.
• No memory barriers — fast but not thread-safe.
• Does NOT implement Send or Sync.
• Compiler enforces single-thread usage.

1use std::rc::Rc;
2
3let data = Rc::new(String::from("shared data"));
4let ref1 = Rc::clone(&data);
5let ref2 = Rc::clone(&data);
6
7println!("Strong: {}, Weak: {}",
8    Rc::strong_count(&data),
9    Rc::weak_count(&data));  // 3, 0

Arc — atomic, multi-thread:

• Uses atomic operations with memory ordering.
• Thread-safe: implements Send + Sync.
• Required for sharing data across threads.
• ~3-10x slower per operation than Rc.

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

When to use Rc:

• Single-threaded shared data.
• Performance-critical paths.
• Simple shared structures.

When to use Arc:

• Multi-threaded applications.
• Concurrent data sharing.
• When data crosses thread boundaries.

Common mistakes:

• Using Rc in multi-threaded code.
• Using Arc in single-threaded code unnecessarily.
• Forgetting that Arc only protects the pointer, not the inner data.