--- name: m02-resource description: "CRITICAL: Use for smart pointers and resource management. Triggers: Box, Rc, Arc, Weak, RefCell, Cell, smart pointer, heap allocation, reference counting, RAII, Drop, should I use Box or Rc, when to use Arc vs Rc, 智能指针, 引用计数, 堆分配" user-invocable: false --- # 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 | Error | Don't Just Say | Ask Instead | |-------|----------------|-------------| | "Need heap allocation" | "Use Box" | Why can't this be on stack? | | Rc memory leak | "Use Weak" | Is the cycle necessary in design? | | RefCell panic | "Use try_borrow" | Is runtime check the right approach? | | Arc overhead complaint | "Accept it" | Is multi-thread access actually needed? | --- ## 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) ``` | Situation | Trace To | Question | |-----------|----------|----------| | Rc vs Arc confusion | m07-concurrency | What's the concurrency model? | | RefCell panics | m03-mutability | Is interior mutability right here? | | Memory leaks | m12-lifecycle | Where should cleanup happen? | --- ## Trace Down ↓ From design to implementation: ``` "Need single-owner heap data" ↓ Use: Box "Need shared immutable data (single-thread)" ↓ Use: Rc "Need shared immutable data (multi-thread)" ↓ Use: Arc "Need to break reference cycle" ↓ Use: Weak "Need shared mutable data" ↓ Single-thread: Rc> ↓ Multi-thread: Arc> or Arc> ``` --- ## Quick Reference | Type | Ownership | Thread-Safe | Use When | |------|-----------|-------------|----------| | `Box` | Single | Yes | Heap allocation, recursive types | | `Rc` | Shared | No | Single-thread shared ownership | | `Arc` | Shared | Yes | Multi-thread shared ownership | | `Weak` | Weak ref | Same as Rc\/Arc | Break reference cycles | | `Cell` | Single | No | Interior mutability (Copy types) | | `RefCell` | Single | No | Interior mutability (runtime check) | ## Decision Flowchart ``` Need heap allocation? ├─ Yes → Single owner? │ ├─ Yes → Box │ └─ No → Multi-thread? │ ├─ Yes → Arc │ └─ No → Rc └─ 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 or RwLock │ └─ No → T: Copy? → Cell : RefCell └─ No → Use &mut T ``` --- ## Common Errors | Problem | Cause | Fix | |---------|-------|-----| | Rc cycle leak | Mutual strong refs | Use Weak for one direction | | RefCell panic | Borrow conflict at runtime | Use try_borrow or restructure | | Arc overhead | Atomic ops in hot path | Consider Rc if single-threaded | | Box unnecessary | Data fits on stack | Remove Box | --- ## Anti-Patterns | Anti-Pattern | Why Bad | Better | |--------------|---------|--------| | Arc everywhere | Unnecessary atomic overhead | Use Rc for single-thread | | RefCell everywhere | Runtime panics | Design clear ownership | | Box for small types | Unnecessary allocation | Stack allocation | | Ignore Weak for cycles | Memory leaks | Design parent-child with Weak | --- ## Related Skills | When | See | |------|-----| | Ownership errors | m01-ownership | | Interior mutability details | m03-mutability | | Multi-thread context | m07-concurrency | | Resource lifecycle | m12-lifecycle |