Rust资源生命周期管理指南：RAII、惰性初始化、连接池模式详解

m12-lifecycle by actionbook/rust-skills

245 周安装量

980 GitHub Stars

GitHub

安装命令

npx skills add https://github.com/actionbook/rust-skills --skill m12-lifecycle

开发系统架构 Rust

🇨🇳中文介绍

资源生命周期

第二层：设计选择

核心问题

此资源应在何时创建、使用和清理？

在实现生命周期之前：

资源的范围是什么？
谁负责清理？
出错时会发生什么？

生命周期模式 → 实现

模式	时机	实现
RAII	自动清理	`Drop` trait
惰性初始化	延迟创建	`OnceLock`, `LazyLock`
池	重用昂贵资源

广告位招租

在这里展示您的产品或服务

触达数万 AI 开发者，精准高效

联系我们

相关 Skills

find-skills 技能搜索工具 - Vercel Labs 开源智能体技能包管理器

896,800 周安装

Vercel React 最佳实践指南 | 58条Next.js性能优化规则与代码重构

290,500 周安装

Vercel Web界面规范检查工具 - 自动检测代码是否符合Web设计指南

233,800 周安装

agent-browser 浏览器自动化工具 - Vercel Labs 命令行网页操作与测试

163,300 周安装

设计生命周期之前：

资源成本是多少？

 * 廉价 → 每次使用创建

 * 昂贵 → 池化或缓存
 * 全局 → 惰性单例

2. 作用域是什么？

 * 函数局部 → 栈分配
 * 请求作用域 → 传递或提取
 * 应用全局 → 静态或 Arc

3. 错误如何处理？

 * 必须清理 → Drop
 * 清理可选 → 显式关闭
 * 清理可能失败 → 从 close 返回 Result

到领域约束（第三层）：

"我应该如何管理数据库连接？"
    ↑ 问：连接成本是多少？
    ↑ 检查：domain-*（延迟要求）
    ↑ 检查：基础设施（连接限制）

问题	追溯至	询问
连接池	domain-*	可接受的延迟是多少？
资源限制	domain-*	基础设施约束是什么？
事务作用域	domain-*	哪些操作必须是原子的？

到实现（第一层）：

"需要自动清理"
    ↓ m02-resource: 实现 Drop
    ↓ m01-ownership: 明确清理责任的所有者

"需要惰性初始化"
    ↓ m03-mutability: 使用 OnceLock 实现线程安全
    ↓ m07-concurrency: 使用 LazyLock 实现同步

"需要连接池"
    ↓ m07-concurrency: 线程安全的池
    ↓ m02-resource: 使用 Arc 共享

模式	类型	用例
RAII	`Drop` trait	作用域退出时自动清理
惰性初始化	`OnceLock`, `LazyLock`	延迟初始化
池	`r2d2`, `deadpool`	连接重用
守卫	`MutexGuard`	作用域锁释放
作用域	自定义结构体	事务边界

事件	Rust 机制
创建	`new()`, `Default`
惰性初始化	`OnceLock::get_or_init`
使用	`&self`, `&mut self`
清理	`Drop::drop()`

struct FileGuard {
    path: PathBuf,
    _handle: File,
}

impl Drop for FileGuard {
    fn drop(&mut self) {
        // 清理：删除临时文件
        let _ = std::fs::remove_file(&self.path);
    }
}

use std::sync::OnceLock;

static CONFIG: OnceLock<Config> = OnceLock::new();

fn get_config() -> &'static Config {
    CONFIG.get_or_init(|| {
        Config::load().expect("config required")
    })
}

错误	原因	修复方法
资源泄漏	忘记 Drop	实现 Drop 或 RAII 包装器
双重释放	手动内存管理	让 Rust 处理
释放后使用	悬垂引用	检查生命周期
E0509 从 Drop 中移出	移动了拥有所有权的字段	`Option::take()`
池耗尽	未归还资源	确保 Drop 会归还

反模式	为何不好	更好的方案
手动清理	容易忘记	RAII/Drop
`lazy_static!`	外部依赖	`std::sync::OnceLock`
全局可变状态	线程不安全	`OnceLock` 或适当的同步
忘记关闭	资源泄漏	实现 Drop

时机	参见
智能指针	m02-resource
线程安全初始化	m07-concurrency
领域作用域	m09-domain
清理中的错误	m06-error-handling

🇺🇸English

Resource Lifecycle

Layer 2: Design Choices

Core Question

When should this resource be created, used, and cleaned up?

Before implementing lifecycle:

What's the resource's scope?
Who owns the cleanup responsibility?
What happens on error?

Lifecycle Pattern → Implementation

Pattern	When	Implementation
RAII	Auto cleanup	`Drop` trait
Lazy init	Deferred creation	`OnceLock`, `LazyLock`
Pool	Reuse expensive resources	`r2d2`, `deadpool`
Guard	Scoped access	`MutexGuard` pattern
Scope	Transaction boundary	Custom struct + Drop

Thinking Prompt

Before designing lifecycle:

What's the resource cost?
- Cheap → create per use
- Expensive → pool or cache
- Global → lazy singleton
What's the scope?
- Function-local → stack allocation
- Request-scoped → passed or extracted
- Application-wide → static or Arc
What about errors?
- Cleanup must happen → Drop
- Cleanup is optional → explicit close
- Cleanup can fail → Result from close

Trace Up ↑

To domain constraints (Layer 3):

"How should I manage database connections?"
    ↑ Ask: What's the connection cost?
    ↑ Check: domain-* (latency requirements)
    ↑ Check: Infrastructure (connection limits)

Question	Trace To	Ask
Connection pooling	domain-*	What's acceptable latency?
Resource limits	domain-*	What are infra constraints?
Transaction scope	domain-*	What must be atomic?

Trace Down ↓

To implementation (Layer 1):

"Need automatic cleanup"
    ↓ m02-resource: Implement Drop
    ↓ m01-ownership: Clear owner for cleanup

"Need lazy initialization"
    ↓ m03-mutability: OnceLock for thread-safe
    ↓ m07-concurrency: LazyLock for sync

"Need connection pool"
    ↓ m07-concurrency: Thread-safe pool
    ↓ m02-resource: Arc for sharing

Quick Reference

Pattern	Type	Use Case
RAII	`Drop` trait	Auto cleanup on scope exit
Lazy Init	`OnceLock`, `LazyLock`	Deferred initialization
Pool	`r2d2`, `deadpool`	Connection reuse
Guard	`MutexGuard`	Scoped lock release

Lifecycle Events

Event	Rust Mechanism
Creation	`new()`, `Default`
Lazy Init	`OnceLock::get_or_init`
Usage	`&self`, `&mut self`
Cleanup	`Drop::drop()`

Pattern Templates

RAII Guard

struct FileGuard {
    path: PathBuf,
    _handle: File,
}

impl Drop for FileGuard {
    fn drop(&mut self) {
        // Cleanup: remove temp file
        let _ = std::fs::remove_file(&self.path);
    }
}

Lazy Singleton

use std::sync::OnceLock;

static CONFIG: OnceLock<Config> = OnceLock::new();

fn get_config() -> &'static Config {
    CONFIG.get_or_init(|| {
        Config::load().expect("config required")
    })
}

Common Errors

Error	Cause	Fix
Resource leak	Forgot Drop	Implement Drop or RAII wrapper
Double free	Manual memory	Let Rust handle
Use after drop	Dangling reference	Check lifetimes
E0509 move out of Drop	Moving owned field	`Option::take()`
Pool exhaustion	Not returned	Ensure Drop returns

Anti-Patterns

Anti-Pattern	Why Bad	Better
Manual cleanup	Easy to forget	RAII/Drop
`lazy_static!`	External dep	`std::sync::OnceLock`
Global mutable state	Thread unsafety	`OnceLock` or proper sync
Forget to close	Resource leak	Drop impl

Related Skills

When	See
Smart pointers	m02-resource
Thread-safe init	m07-concurrency
Domain scopes	m09-domain
Error in cleanup	m06-error-handling

Weekly Installs

Repository

actionbook/rust-skills

GitHub Stars

828

First Seen

Jan 23, 2026

Security Audits

Gen Agent Trust HubPass SocketPass SnykPass

Installed on

gemini-cli36

opencode36

codex35

github-copilot32

cursor31

claude-code30

React 组合模式指南：Vercel 组件架构最佳实践，提升代码可维护性

120,000 周安装

Rust资源生命周期管理指南：RAII、惰性初始化、连接池模式详解

🇨🇳中文介绍

资源生命周期

核心问题

生命周期模式 → 实现

相关 Skills

思考提示

向上追溯 ↑

向下追溯 ↓

快速参考

生命周期事件

模式模板

RAII 守卫

惰性单例

常见错误

反模式

相关技能