M02 Resource

作者 actionbook5c40d3ad7851無授權條款1.5K 個星標收錄於 2026年10月8日更新於 2026年10月8日儲存庫6 週前更新

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, 智能指针, 引用计数, 堆分配

僅含說明Software Development

AI 產生的概覽

指導 Rust 開發者選擇智慧指標與所有權模式，例如 Box、Rc、Arc、Weak、Cell 和 RefCell。

功能: 這個技能是 Rust 資源管理的決策指南。它梳理所有權模型、執行緒情境和參照循環，再把具體情況對應到 Box、Rc、Arc、Weak、Cell、RefCell 等型別。它也列出常見錯誤、反模式，以及在指標選擇不明確時可參考的相關主題。
適用情境: 當需要在智慧指標之間做選擇時使用，例如 Box 與 Rc、Arc 與 Rc 的取捨，或排查 Rc 記憶體洩漏、RefCell panic、Arc 額外開銷過大等問題。它也適合用來思考堆積配置、參照計數、RAII 或 Drop 行為。
執行需求: 不需要任何工具、套件或憑證；這個技能只包含說明，沒有腳本。

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:

What's the ownership model?
- Single owner → Box or owned value
- Shared ownership → Rc/Arc
- Weak reference → Weak
What's the thread context?
- Single-thread → Rc, Cell, RefCell
- Multi-thread → Arc, Mutex, RwLock
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)

"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<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>>

"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

Type	Ownership	Thread-Safe	Use When
`Box<T>`	Single	Yes	Heap allocation, recursive types
`Rc<T>`	Shared	No	Single-thread shared ownership
`Arc<T>`	Shared	Yes	Multi-thread shared ownership
`Weak<T>`	Weak ref	Same as Rc/Arc	Break reference cycles
`Cell<T>`	Single	No	Interior mutability (Copy types)
`RefCell<T>`	Single	No	Interior mutability (runtime check)

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

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

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

來源與署名

來源：actionbook/rust-skills位於skills/m02-resource提交5c40d3a

授權條款：無授權條款

內容歸原作者所有。SourceWeft 從公開儲存庫中收錄這些內容。

檢舉或申請下架

When	See
Ownership errors	m01-ownership
Interior mutability details	m03-mutability
Multi-thread context	m07-concurrency
Resource lifecycle	m12-lifecycle

M02 Resource

Resource Management

Core Question

Error → Design Question

Thinking Prompt

Trace Up ↑

Trace Down ↓

Quick Reference

Decision Flowchart

Common Errors

Anti-Patterns

Related Skills

來源與署名

更多來自 actionbook/rust-skills 的技能

Rust Trait Explorer

Rust Symbol Analyzer

Rust Skill Creator

Rust Router

Rust Refactor Helper

Rust Daily

更多Software Development技能

Playground

M5 Onboard

Cardputer Buddy

Web Design Guidelines

Vercel React Native Skills

Vercel React Best Practices