Resource Management

Layer 1: Language Mechanics

Core Question

What ownership pattern does this resource need?

Before choosing a smart pointer, understand:

• Is ownership single or shared?
• Is access single-threaded or multi-threaded?
• Are there potential cycles?

Error → Design Question

Thinking Prompt

Before choosing a smart pointer:

1. What's the ownership model?

   • Single owner → Box or owned value
   • Shared ownership → Rc/Arc
   • Weak reference → Weak

2. What's the thread context?

   • Single-thread → Rc, Cell, RefCell
   • Multi-thread → Arc, Mutex, RwLock

3. Are there cycles?

   • Yes → One direction must be Weak
   • No → Regular Rc/Arc is fine

Trace Up ↑

When pointer choice is unclear, trace to design:

"Should I use Arc or Rc?"
    ↑ Ask: Is this data shared across threads?
    ↑ Check: m07-concurrency (thread model)
    ↑ Check: domain-* (performance constraints)

Trace Down ↓

From design to implementation:

"Need single-owner heap data"
    ↓ Use: Box<T>

"Need shared immutable data (single-thread)"
    ↓ Use: Rc<T>

"Need shared immutable data (multi-thread)"
    ↓ Use: Arc<T>

"Need to break reference cycle"
    ↓ Use: Weak<T>

"Need shared mutable data"
    ↓ Single-thread: Rc<RefCell<T>>
    ↓ Multi-thread: Arc<Mutex<T>> or Arc<RwLock<T>>

Quick Reference

Decision Flowchart

Need heap allocation?
├─ Yes → Single owner?
│        ├─ Yes → Box<T>
│        └─ No → Multi-thread?
│                ├─ Yes → Arc<T>
│                └─ No → Rc<T>
└─ No → Stack allocation (default)

Have reference cycles?
├─ Yes → Use Weak for one direction
└─ No → Regular Rc/Arc

Need interior mutability?
├─ Yes → Thread-safe needed?
│        ├─ Yes → Mutex<T> or RwLock<T>
│        └─ No → T: Copy? → Cell<T> : RefCell<T>
└─ No → Use &mut T

Common Errors

Anti-Patterns

Related Skills