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 option.

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

let settings = Rc::new(vec!["theme:dark", "lang:en"]);
let ui = Rc::clone(&settings);
let api = Rc::clone(&settings);

println!("UI: {:?}", *ui);
println!("API: {:?}", *api);
println!("Count: {}", Rc::strong_count(&settings));  // 3
```

**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 words = Arc::new(vec!["hello", "world", "rust"]);
let mut handles = vec![];

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