What is the difference between Rc and Arc?

Question

Accepted Answer

**Rc** = reference counted, NOT thread-safe, non-atomic. **Arc** = atomic reference counted, thread-safe, 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.

```rust
use std::rc::Rc;

let shared = Rc::new(vec![1, 2, 3]);
let a = Rc::clone(&shared);
let b = Rc::clone(&shared);

println!("Count: {}", Rc::strong_count(&shared));  // 3
println!("Values: {:?} {:?} {:?}", *shared, *a, *b);
```

**Arc — safe, multi-threaded:**
- Atomic increment/decrement.
- Implements Send + Sync.
- Required for cross-thread sharing.
- Essential for concurrent code.

```rust
use std::sync::Arc;
use std::thread;

let data = Arc::new(vec!["a", "b", "c"]);
let mut handles = vec![];

for i in 0..3 {
    let d = Arc::clone(&data);
    handles.push(thread::spawn(move || {
        println!("Thread {}: {:?}", i, *d);
    }));
}
for 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.

Rust: What is the difference between Rc and Arc?