Rust Memory Management: Ownership vs. Reference Counting

Rust's signature achievement is memory safety without a garbage collector. It accomplishes this through a disciplined ownership system – but that system deliberately has an escape hatch: reference counting.

Every value in a Rust program has a single owner at any given time. When that owner goes out of scope, the value is dropped – memory freed, deterministically, at a known point in execution. No GC pause, no dangling pointer, no double-free. The compiler enforces all of this statically.

But some data genuinely needs to be shared: a node in a graph owned by multiple edges, a configuration object threaded through many subsystems, a callback holding a reference into surrounding state. Enter reference counting – Rc<T> and Arc<T> – which shift ownership logic from compile time into a small runtime counter.

These are not competing features. They are complementary tools with distinct trade-offs. This article unpacks both – semantics, performance, ergonomics, and the decisive question: which should you reach for?

The ownership model is Rust's core innovation. Every heap allocation has exactly one owner – the variable binding that "holds" it. Ownership can be moved to another binding, at which point the original is invalidated. It can never be silently copied (unless the type implements Copy).

fn main() {
    let s1 = String::from("hello");
    let s2 = s1; // ownership MOVED – s1 is now invalid
    // println!("{}", s1); – compile error: value borrowed after move
    println!("{}", s2); // fine – s2 is the sole owner
} // s2 dropped here, memory freed automatically

The borrow checker enforces the ownership rules. When s1 is assigned to s2, the compiler understands that s1 can no longer be used – it has given up ownership. This eliminates use-after-free at zero runtime cost.

Moving ownership everywhere would be cumbersome. Rust lets you borrow a value: take a temporary, scoped reference without transferring ownership. The borrow checker enforces two invariants simultaneously: multiple shared (&T) borrows may coexist, OR exactly one mutable (&mut T) borrow may exist at a time. This is aliasing XOR mutability – a fundamental rule that eliminates entire categories of bugs statically.

Rc<T> and Arc<T> provide shared ownership. Rc<T> (Reference Counted) wraps a value on the heap with a counter. Every clone increments the count; every drop decrements it. When it reaches zero, the value is freed. Arc<T> (Atomically Reference Counted) uses atomic operations for thread safety.

The overhead of Rc<T> is three-fold: one extra heap allocation, one pointer indirection, and counter increments/decrements. Arc<T> adds further cost due to atomic memory-ordering guarantees. Use Rc/Arc when the alternative is fighting the borrow checker with complex lifetime annotations; the small runtime cost buys you ergonomic, safe shared ownership.