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?

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

fn calculate_length(s: &String) -> usize {
    s.len()
}  // s goes out of scope but does NOT drop the String

fn append_world(s: &mut String) {
    s.push_str(", world");
}

fn main() {
    let mut greeting = String::from("hello");

    let len = calculate_length(&greeting); // shared borrow
    append_world(&mut greeting);          // mutable borrow

    println!("'{}' has {} characters", greeting, len);
}

// 'a says: the returned reference lives at least as long as both inputs
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() >= y.len() { x } else { y }
}

Key Properties

Ownership & Borrowing is zero-cost: all safety guarantees are verified at compile time and produce no runtime overhead — no counter increments, no heap allocations beyond the value itself, no extra indirection.

use std::rc::Rc;

fn main() {
    let a = Rc::new(String::from("shared data"));
    let b = Rc::clone(&a);  // increments strong count — cheap pointer clone
    let c = Rc::clone(&a);

    println!("strong count = {}", Rc::strong_count(&a)); // 3

    drop(b);
    println!("after drop b = {}", Rc::strong_count(&a)); // 2

} // a and c drop here; count → 0 → String is freed

use std::rc::Rc;
use std::cell::RefCell;

fn main() {
    let shared = Rc::new(RefCell::new(vec![1, 2, 3]));

    let clone1 = Rc::clone(&shared);
    let clone2 = Rc::clone(&shared);

    clone1.borrow_mut().push(4);  // runtime borrow check
    clone2.borrow_mut().push(5);

    println!("{:?}", shared.borrow()); // [1, 2, 3, 4, 5]
}

use std::sync::{Arc, Mutex};
use std::thread;

fn main() {
    let counter = Arc::new(Mutex::new(0u32));

    let handles: Vec<_> = (0..8).map(|_| {
        let c = Arc::clone(&counter);
        thread::spawn(move || {
            *c.lock().unwrap() += 1;
        })
    }).collect();

    for h in handles { h.join().unwrap(); }
    println!("count = {}", *counter.lock().unwrap()); // 8
}

Watch Out — Reference Cycles

Rc<T> and Arc<T> cannot automatically detect reference cycles. If two Rc values hold each other, their strong counts never reach zero and you leak memory. Use Weak<T> for back-references (e.g., parent pointers in a tree) to break cycles.

Rule of Thumb

Reach for Rc/Arc when the alternative is fighting the borrow checker with complex lifetime annotations or unsafe code. The small runtime cost buys you ergonomic, safe shared ownership — a reasonable trade in most application code.

// Classic use case: graph with shared nodes
use std::rc::{Rc, Weak};
use std::cell::RefCell;

struct Node {
    value: i32,
    children: Vec<Rc<RefCell<Node>>>>,
    parent: Option<Weak<RefCell<Node>>>>, // Weak breaks parent→child cycle
}

impl Node {
    fn new(value: i32) -> Rc<RefCell<Node>> {
        Rc::new(RefCell::new(Node {
            value,
            children: vec![],
            parent: None,
        }))
    }
}