M12 Lifecycle

by actionbook5c40d3ad7851No license1.5K starsListed Oct 8, 2026Updated Oct 8, 2026Repository updated 6 weeks ago

Use when designing resource lifecycles. Keywords: RAII, Drop, resource lifecycle, connection pool, lazy initialization, connection pool design, resource cleanup patterns, cleanup, scope, OnceCell, Lazy, once_cell, OnceLock, transaction, session management, when is Drop called, cleanup on error, guard pattern, scope guard, 资源生命周期, 连接池, 惰性初始化, 资源清理, RAII 模式

Instructions onlySoftware Development

AI-generated overview

Guides design choices for resource lifecycles in Rust, covering RAII, lazy init, pooling, guards and cleanup.

What it does: This skill provides a design framework for deciding when a resource should be created, used and cleaned up. It maps lifecycle patterns such as RAII, lazy initialization, pooling, guards and transaction scopes to Rust mechanisms like Drop, OnceLock, LazyLock, r2d2 and deadpool. It also lists lifecycle events, pattern templates, common errors and anti-patterns, and points to related skills for ownership, concurrency, domain scoping and error handling.
When to use it: Use it when designing how a resource is created, shared and released, such as connection pools, lazy singletons, scoped guards or transaction boundaries. It is also useful when deciding cleanup responsibility and error behavior during cleanup.
Requirements: No scripts or tooling are required; it is an instructions-only reference. The examples assume Rust and mention crates such as r2d2 and deadpool, but nothing needs to be installed to read the guidance.

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)

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

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

"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
Scope	Custom struct	Transaction boundaries

Lifecycle Events

Pattern Templates

RAII Guard

rust

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);    }}

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

rust

use std::sync::OnceLock;
static CONFIG: OnceLock<Config> = OnceLock::new();
fn get_config() -> &'static Config {    CONFIG.get_or_init(|| {        Config::load().expect("config required")    })}

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

Source and attribution

Source:actionbook/rust-skillsinskills/m12-lifecycleat commit5c40d3a

License: No license

Content belongs to its original authors. SourceWeft indexes it from a public repository.

Report or request removal

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?

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

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

M12 Lifecycle

Resource Lifecycle

Core Question

Lifecycle Pattern → Implementation

Thinking Prompt

Trace Up ↑

Trace Down ↓

Quick Reference

Lifecycle Events

Pattern Templates

RAII Guard

Lazy Singleton

Common Errors

Anti-Patterns

Related Skills

Source and attribution

More from actionbook/rust-skills

Rust Trait Explorer

Rust Symbol Analyzer

Rust Skill Creator

Rust Router

Rust Refactor Helper

Rust Daily

More in Software Development

Playground

M5 Onboard

Cardputer Buddy

Web Design Guidelines

Vercel React Native Skills

Vercel React Best Practices