[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M70KF8GYREKFDFKR0JZE1R8K":3,"skill-same:01M70KF8GYREKFDFKR0JZE1R8K":72},{"skillNo":4,"name":5,"nameZh":6,"description":7,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":16,"categories":17,"keywords":23,"publishedAt":43,"linkOnly":44,"markdownContent":45,"markdownBody":46,"frontMatter":47,"refName":48,"commitSha":49,"skillDirectory":50,"forksCount":51,"repositoryHtmlUrl":52,"repositoryHomepageUrl":53,"ownerHtmlUrl":54,"ownerBlogUrl":55,"ownerDescription":56,"updatedAt":57,"install":58,"resources":71},"01M70KF8GYREKFDFKR0JZE1R8K","rust-async-patterns",null,"Master Rust async programming with Tokio, async traits, error handling, and concurrent patterns. Use when building async Rust applications, implementing concurrent systems, or debugging async code.","shengdabai\u002FTony-Claude-Code-Skills","shengdabai","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F116417419?v=4","01M70F6D2WY5PQV5A92BKYJQEW","Tony Sheng","01M70F6D3GAAAYZ5H4CC1G8VXM",3,"MIT","https:\u002F\u002Fgithub.com\u002Fshengdabai\u002FTony-Claude-Code-Skills\u002Fblob\u002Fmain\u002Fskills\u002F_collections\u002Fwshobson-agents\u002Fplugins\u002Fsystems-programming\u002Fskills\u002Frust-async-patterns\u002FSKILL.md",[18],{"categoryNo":19,"categoryName":20,"taxonomyType":21,"taxonomyTypeDesc":22},"01JBSEEDCAT000000000000030","开发工程师","PROFESSION","适用职业",[24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42],"rust async patterns","patterns","async","rust","systems","with","error handling","programming","use","async programming","applications","master","code","traits","when","debugging","implementing","tokio","error","2026-11-10 10:12:30",false,"---\nname: rust-async-patterns\ndescription: Master Rust async programming with Tokio, async traits, error handling, and concurrent patterns. Use when building async Rust applications, implementing concurrent systems, or debugging async code.\n---\n\n# Rust Async Patterns\n\nProduction patterns for async Rust programming with Tokio runtime, including tasks, channels, streams, and error handling.\n\n## When to Use This Skill\n\n- Building async Rust applications\n- Implementing concurrent network services\n- Using Tokio for async I\u002FO\n- Handling async errors properly\n- Debugging async code issues\n- Optimizing async performance\n\n## Core Concepts\n\n### 1. Async Execution Model\n\n```\nFuture (lazy) → poll() → Ready(value) | Pending\n                ↑           ↓\n              Waker ← Runtime schedules\n```\n\n### 2. Key Abstractions\n\n| Concept | Purpose |\n|---------|---------|\n| `Future` | Lazy computation that may complete later |\n| `async fn` | Function returning impl Future |\n| `await` | Suspend until future completes |\n| `Task` | Spawned future running concurrently |\n| `Runtime` | Executor that polls futures |\n\n## Quick Start\n\n```toml\n# Cargo.toml\n[dependencies]\ntokio = { version = \"1\", features = [\"full\"] }\nfutures = \"0.3\"\nasync-trait = \"0.1\"\nanyhow = \"1.0\"\ntracing = \"0.1\"\ntracing-subscriber = \"0.3\"\n```\n\n```rust\nuse tokio::time::{sleep, Duration};\nuse anyhow::Result;\n\n#[tokio::main]\nasync fn main() -> Result\u003C()> {\n    \u002F\u002F Initialize tracing\n    tracing_subscriber::fmt::init();\n\n    \u002F\u002F Async operations\n    let result = fetch_data(\"https:\u002F\u002Fapi.example.com\").await?;\n    println!(\"Got: {}\", result);\n\n    Ok(())\n}\n\nasync fn fetch_data(url: &str) -> Result\u003CString> {\n    \u002F\u002F Simulated async operation\n    sleep(Duration::from_millis(100)).await;\n    Ok(format!(\"Data from {}\", url))\n}\n```\n\n## Patterns\n\n### Pattern 1: Concurrent Task Execution\n\n```rust\nuse tokio::task::JoinSet;\nuse anyhow::Result;\n\n\u002F\u002F Spawn multiple concurrent tasks\nasync fn fetch_all_concurrent(urls: Vec\u003CString>) -> Result\u003CVec\u003CString>> {\n    let mut set = JoinSet::new();\n\n    for url in urls {\n        set.spawn(async move {\n            fetch_data(&url).await\n        });\n    }\n\n    let mut results = Vec::new();\n    while let Some(res) = set.join_next().await {\n        match res {\n            Ok(Ok(data)) => results.push(data),\n            Ok(Err(e)) => tracing::error!(\"Task failed: {}\", e),\n            Err(e) => tracing::error!(\"Join error: {}\", e),\n        }\n    }\n\n    Ok(results)\n}\n\n\u002F\u002F With concurrency limit\nuse futures::stream::{self, StreamExt};\n\nasync fn fetch_with_limit(urls: Vec\u003CString>, limit: usize) -> Vec\u003CResult\u003CString>> {\n    stream::iter(urls)\n        .map(|url| async move { fetch_data(&url).await })\n        .buffer_unordered(limit) \u002F\u002F Max concurrent tasks\n        .collect()\n        .await\n}\n\n\u002F\u002F Select first to complete\nuse tokio::select;\n\nasync fn race_requests(url1: &str, url2: &str) -> Result\u003CString> {\n    select! {\n        result = fetch_data(url1) => result,\n        result = fetch_data(url2) => result,\n    }\n}\n```\n\n### Pattern 2: Channels for Communication\n\n```rust\nuse tokio::sync::{mpsc, broadcast, oneshot, watch};\n\n\u002F\u002F Multi-producer, single-consumer\nasync fn mpsc_example() {\n    let (tx, mut rx) = mpsc::channel::\u003CString>(100);\n\n    \u002F\u002F Spawn producer\n    let tx2 = tx.clone();\n    tokio::spawn(async move {\n        tx2.send(\"Hello\".to_string()).await.unwrap();\n    });\n\n    \u002F\u002F Consume\n    while let Some(msg) = rx.recv().await {\n        println!(\"Got: {}\", msg);\n    }\n}\n\n\u002F\u002F Broadcast: multi-producer, multi-consumer\nasync fn broadcast_example() {\n    let (tx, _) = broadcast::channel::\u003CString>(100);\n\n    let mut rx1 = tx.subscribe();\n    let mut rx2 = tx.subscribe();\n\n    tx.send(\"Event\".to_string()).unwrap();\n\n    \u002F\u002F Both receivers get the message\n    let _ = rx1.recv().await;\n    let _ = rx2.recv().await;\n}\n\n\u002F\u002F Oneshot: single value, single use\nasync fn oneshot_example() -> String {\n    let (tx, rx) = oneshot::channel::\u003CString>();\n\n    tokio::spawn(async move {\n        tx.send(\"Result\".to_string()).unwrap();\n    });\n\n    rx.await.unwrap()\n}\n\n\u002F\u002F Watch: single producer, multi-consumer, latest value\nasync fn watch_example() {\n    let (tx, mut rx) = watch::channel(\"initial\".to_string());\n\n    tokio::spawn(async move {\n        loop {\n            \u002F\u002F Wait for changes\n            rx.changed().await.unwrap();\n            println!(\"New value: {}\", *rx.borrow());\n        }\n    });\n\n    tx.send(\"updated\".to_string()).unwrap();\n}\n```\n\n### Pattern 3: Async Error Handling\n\n```rust\nuse anyhow::{Context, Result, bail};\nuse thiserror::Error;\n\n#[derive(Error, Debug)]\npub enum ServiceError {\n    #[error(\"Network error: {0}\")]\n    Network(#[from] reqwest::Error),\n\n    #[error(\"Database error: {0}\")]\n    Database(#[from] sqlx::Error),\n\n    #[error(\"Not found: {0}\")]\n    NotFound(String),\n\n    #[error(\"Timeout after {0:?}\")]\n    Timeout(std::time::Duration),\n}\n\n\u002F\u002F Using anyhow for application errors\nasync fn process_request(id: &str) -> Result\u003CResponse> {\n    let data = fetch_data(id)\n        .await\n        .context(\"Failed to fetch data\")?;\n\n    let parsed = parse_response(&data)\n        .context(\"Failed to parse response\")?;\n\n    Ok(parsed)\n}\n\n\u002F\u002F Using custom errors for library code\nasync fn get_user(id: &str) -> Result\u003CUser, ServiceError> {\n    let result = db.query(id).await?;\n\n    match result {\n        Some(user) => Ok(user),\n        None => Err(ServiceError::NotFound(id.to_string())),\n    }\n}\n\n\u002F\u002F Timeout wrapper\nuse tokio::time::timeout;\n\nasync fn with_timeout\u003CT, F>(duration: Duration, future: F) -> Result\u003CT, ServiceError>\nwhere\n    F: std::future::Future\u003COutput = Result\u003CT, ServiceError>>,\n{\n    timeout(duration, future)\n        .await\n        .map_err(|_| ServiceError::Timeout(duration))?\n}\n```\n\n### Pattern 4: Graceful Shutdown\n\n```rust\nuse tokio::signal;\nuse tokio::sync::broadcast;\nuse tokio_util::sync::CancellationToken;\n\nasync fn run_server() -> Result\u003C()> {\n    \u002F\u002F Method 1: CancellationToken\n    let token = CancellationToken::new();\n    let token_clone = token.clone();\n\n    \u002F\u002F Spawn task that respects cancellation\n    tokio::spawn(async move {\n        loop {\n            tokio::select! {\n                _ = token_clone.cancelled() => {\n                    tracing::info!(\"Task shutting down\");\n                    break;\n                }\n                _ = do_work() => {}\n            }\n        }\n    });\n\n    \u002F\u002F Wait for shutdown signal\n    signal::ctrl_c().await?;\n    tracing::info!(\"Shutdown signal received\");\n\n    \u002F\u002F Cancel all tasks\n    token.cancel();\n\n    \u002F\u002F Give tasks time to cleanup\n    tokio::time::sleep(Duration::from_secs(5)).await;\n\n    Ok(())\n}\n\n\u002F\u002F Method 2: Broadcast channel for shutdown\nasync fn run_with_broadcast() -> Result\u003C()> {\n    let (shutdown_tx, _) = broadcast::channel::\u003C()>(1);\n\n    let mut rx = shutdown_tx.subscribe();\n    tokio::spawn(async move {\n        tokio::select! {\n            _ = rx.recv() => {\n                tracing::info!(\"Received shutdown\");\n            }\n            _ = async { loop { do_work().await } } => {}\n        }\n    });\n\n    signal::ctrl_c().await?;\n    let _ = shutdown_tx.send(());\n\n    Ok(())\n}\n```\n\n### Pattern 5: Async Traits\n\n```rust\nuse async_trait::async_trait;\n\n#[async_trait]\npub trait Repository {\n    async fn get(&self, id: &str) -> Result\u003CEntity>;\n    async fn save(&self, entity: &Entity) -> Result\u003C()>;\n    async fn delete(&self, id: &str) -> Result\u003C()>;\n}\n\npub struct PostgresRepository {\n    pool: sqlx::PgPool,\n}\n\n#[async_trait]\nimpl Repository for PostgresRepository {\n    async fn get(&self, id: &str) -> Result\u003CEntity> {\n        sqlx::query_as!(Entity, \"SELECT * FROM entities WHERE id = $1\", id)\n            .fetch_one(&self.pool)\n            .await\n            .map_err(Into::into)\n    }\n\n    async fn save(&self, entity: &Entity) -> Result\u003C()> {\n        sqlx::query!(\n            \"INSERT INTO entities (id, data) VALUES ($1, $2)\n             ON CONFLICT (id) DO UPDATE SET data = $2\",\n            entity.id,\n            entity.data\n        )\n        .execute(&self.pool)\n        .await?;\n        Ok(())\n    }\n\n    async fn delete(&self, id: &str) -> Result\u003C()> {\n        sqlx::query!(\"DELETE FROM entities WHERE id = $1\", id)\n            .execute(&self.pool)\n            .await?;\n        Ok(())\n    }\n}\n\n\u002F\u002F Trait object usage\nasync fn process(repo: &dyn Repository, id: &str) -> Result\u003C()> {\n    let entity = repo.get(id).await?;\n    \u002F\u002F Process...\n    repo.save(&entity).await\n}\n```\n\n### Pattern 6: Streams and Async Iteration\n\n```rust\nuse futures::stream::{self, Stream, StreamExt};\nuse async_stream::stream;\n\n\u002F\u002F Create stream from async iterator\nfn numbers_stream() -> impl Stream\u003CItem = i32> {\n    stream! {\n        for i in 0..10 {\n            tokio::time::sleep(Duration::from_millis(100)).await;\n            yield i;\n        }\n    }\n}\n\n\u002F\u002F Process stream\nasync fn process_stream() {\n    let stream = numbers_stream();\n\n    \u002F\u002F Map and filter\n    let processed: Vec\u003C_> = stream\n        .filter(|n| futures::future::ready(*n % 2 == 0))\n        .map(|n| n * 2)\n        .collect()\n        .await;\n\n    println!(\"{:?}\", processed);\n}\n\n\u002F\u002F Chunked processing\nasync fn process_in_chunks() {\n    let stream = numbers_stream();\n\n    let mut chunks = stream.chunks(3);\n\n    while let Some(chunk) = chunks.next().await {\n        println!(\"Processing chunk: {:?}\", chunk);\n    }\n}\n\n\u002F\u002F Merge multiple streams\nasync fn merge_streams() {\n    let stream1 = numbers_stream();\n    let stream2 = numbers_stream();\n\n    let merged = stream::select(stream1, stream2);\n\n    merged\n        .for_each(|n| async move {\n            println!(\"Got: {}\", n);\n        })\n        .await;\n}\n```\n\n### Pattern 7: Resource Management\n\n```rust\nuse std::sync::Arc;\nuse tokio::sync::{Mutex, RwLock, Semaphore};\n\n\u002F\u002F Shared state with RwLock (prefer for read-heavy)\nstruct Cache {\n    data: RwLock\u003CHashMap\u003CString, String>>,\n}\n\nimpl Cache {\n    async fn get(&self, key: &str) -> Option\u003CString> {\n        self.data.read().await.get(key).cloned()\n    }\n\n    async fn set(&self, key: String, value: String) {\n        self.data.write().await.insert(key, value);\n    }\n}\n\n\u002F\u002F Connection pool with semaphore\nstruct Pool {\n    semaphore: Semaphore,\n    connections: Mutex\u003CVec\u003CConnection>>,\n}\n\nimpl Pool {\n    fn new(size: usize) -> Self {\n        Self {\n            semaphore: Semaphore::new(size),\n            connections: Mutex::new((0..size).map(|_| Connection::new()).collect()),\n        }\n    }\n\n    async fn acquire(&self) -> PooledConnection\u003C'_> {\n        let permit = self.semaphore.acquire().await.unwrap();\n        let conn = self.connections.lock().await.pop().unwrap();\n        PooledConnection { pool: self, conn: Some(conn), _permit: permit }\n    }\n}\n\nstruct PooledConnection\u003C'a> {\n    pool: &'a Pool,\n    conn: Option\u003CConnection>,\n    _permit: tokio::sync::SemaphorePermit\u003C'a>,\n}\n\nimpl Drop for PooledConnection\u003C'_> {\n    fn drop(&mut self) {\n        if let Some(conn) = self.conn.take() {\n            let pool = self.pool;\n            tokio::spawn(async move {\n                pool.connections.lock().await.push(conn);\n            });\n        }\n    }\n}\n```\n\n## Debugging Tips\n\n```rust\n\u002F\u002F Enable tokio-console for runtime debugging\n\u002F\u002F Cargo.toml: tokio = { features = [\"tracing\"] }\n\u002F\u002F Run: RUSTFLAGS=\"--cfg tokio_unstable\" cargo run\n\u002F\u002F Then: tokio-console\n\n\u002F\u002F Instrument async functions\nuse tracing::instrument;\n\n#[instrument(skip(pool))]\nasync fn fetch_user(pool: &PgPool, id: &str) -> Result\u003CUser> {\n    tracing::debug!(\"Fetching user\");\n    \u002F\u002F ...\n}\n\n\u002F\u002F Track task spawning\nlet span = tracing::info_span!(\"worker\", id = %worker_id);\ntokio::spawn(async move {\n    \u002F\u002F Enters span when polled\n}.instrument(span));\n```\n\n## Best Practices\n\n### Do's\n- **Use `tokio::select!`** - For racing futures\n- **Prefer channels** - Over shared state when possible\n- **Use `JoinSet`** - For managing multiple tasks\n- **Instrument with tracing** - For debugging async code\n- **Handle cancellation** - Check `CancellationToken`\n\n### Don'ts\n- **Don't block** - Never use `std::thread::sleep` in async\n- **Don't hold locks across awaits** - Causes deadlocks\n- **Don't spawn unboundedly** - Use semaphores for limits\n- **Don't ignore errors** - Propagate with `?` or log\n- **Don't forget Send bounds** - For spawned futures\n\n## Resources\n\n- [Tokio Tutorial](https:\u002F\u002Ftokio.rs\u002Ftokio\u002Ftutorial)\n- [Async Book](https:\u002F\u002Frust-lang.github.io\u002Fasync-book\u002F)\n- [Tokio Console](https:\u002F\u002Fgithub.com\u002Ftokio-rs\u002Fconsole)\n","# Rust Async Patterns\n\nProduction patterns for async Rust programming with Tokio runtime, including tasks, channels, streams, and error handling.\n\n## When to Use This Skill\n\n- Building async Rust applications\n- Implementing concurrent network services\n- Using Tokio for async I\u002FO\n- Handling async errors properly\n- Debugging async code issues\n- Optimizing async performance\n\n## Core Concepts\n\n### 1. Async Execution Model\n\n```\nFuture (lazy) → poll() → Ready(value) | Pending\n                ↑           ↓\n              Waker ← Runtime schedules\n```\n\n### 2. Key Abstractions\n\n| Concept | Purpose |\n|---------|---------|\n| `Future` | Lazy computation that may complete later |\n| `async fn` | Function returning impl Future |\n| `await` | Suspend until future completes |\n| `Task` | Spawned future running concurrently |\n| `Runtime` | Executor that polls futures |\n\n## Quick Start\n\n```toml\n# Cargo.toml\n[dependencies]\ntokio = { version = \"1\", features = [\"full\"] }\nfutures = \"0.3\"\nasync-trait = \"0.1\"\nanyhow = \"1.0\"\ntracing = \"0.1\"\ntracing-subscriber = \"0.3\"\n```\n\n```rust\nuse tokio::time::{sleep, Duration};\nuse anyhow::Result;\n\n#[tokio::main]\nasync fn main() -> Result\u003C()> {\n    \u002F\u002F Initialize tracing\n    tracing_subscriber::fmt::init();\n\n    \u002F\u002F Async operations\n    let result = fetch_data(\"https:\u002F\u002Fapi.example.com\").await?;\n    println!(\"Got: {}\", result);\n\n    Ok(())\n}\n\nasync fn fetch_data(url: &str) -> Result\u003CString> {\n    \u002F\u002F Simulated async operation\n    sleep(Duration::from_millis(100)).await;\n    Ok(format!(\"Data from {}\", url))\n}\n```\n\n## Patterns\n\n### Pattern 1: Concurrent Task Execution\n\n```rust\nuse tokio::task::JoinSet;\nuse anyhow::Result;\n\n\u002F\u002F Spawn multiple concurrent tasks\nasync fn fetch_all_concurrent(urls: Vec\u003CString>) -> Result\u003CVec\u003CString>> {\n    let mut set = JoinSet::new();\n\n    for url in urls {\n        set.spawn(async move {\n            fetch_data(&url).await\n        });\n    }\n\n    let mut results = Vec::new();\n    while let Some(res) = set.join_next().await {\n        match res {\n            Ok(Ok(data)) => results.push(data),\n            Ok(Err(e)) => tracing::error!(\"Task failed: {}\", e),\n            Err(e) => tracing::error!(\"Join error: {}\", e),\n        }\n    }\n\n    Ok(results)\n}\n\n\u002F\u002F With concurrency limit\nuse futures::stream::{self, StreamExt};\n\nasync fn fetch_with_limit(urls: Vec\u003CString>, limit: usize) -> Vec\u003CResult\u003CString>> {\n    stream::iter(urls)\n        .map(|url| async move { fetch_data(&url).await })\n        .buffer_unordered(limit) \u002F\u002F Max concurrent tasks\n        .collect()\n        .await\n}\n\n\u002F\u002F Select first to complete\nuse tokio::select;\n\nasync fn race_requests(url1: &str, url2: &str) -> Result\u003CString> {\n    select! {\n        result = fetch_data(url1) => result,\n        result = fetch_data(url2) => result,\n    }\n}\n```\n\n### Pattern 2: Channels for Communication\n\n```rust\nuse tokio::sync::{mpsc, broadcast, oneshot, watch};\n\n\u002F\u002F Multi-producer, single-consumer\nasync fn mpsc_example() {\n    let (tx, mut rx) = mpsc::channel::\u003CString>(100);\n\n    \u002F\u002F Spawn producer\n    let tx2 = tx.clone();\n    tokio::spawn(async move {\n        tx2.send(\"Hello\".to_string()).await.unwrap();\n    });\n\n    \u002F\u002F Consume\n    while let Some(msg) = rx.recv().await {\n        println!(\"Got: {}\", msg);\n    }\n}\n\n\u002F\u002F Broadcast: multi-producer, multi-consumer\nasync fn broadcast_example() {\n    let (tx, _) = broadcast::channel::\u003CString>(100);\n\n    let mut rx1 = tx.subscribe();\n    let mut rx2 = tx.subscribe();\n\n    tx.send(\"Event\".to_string()).unwrap();\n\n    \u002F\u002F Both receivers get the message\n    let _ = rx1.recv().await;\n    let _ = rx2.recv().await;\n}\n\n\u002F\u002F Oneshot: single value, single use\nasync fn oneshot_example() -> String {\n    let (tx, rx) = oneshot::channel::\u003CString>();\n\n    tokio::spawn(async move {\n        tx.send(\"Result\".to_string()).unwrap();\n    });\n\n    rx.await.unwrap()\n}\n\n\u002F\u002F Watch: single producer, multi-consumer, latest value\nasync fn watch_example() {\n    let (tx, mut rx) = watch::channel(\"initial\".to_string());\n\n    tokio::spawn(async move {\n        loop {\n            \u002F\u002F Wait for changes\n            rx.changed().await.unwrap();\n            println!(\"New value: {}\", *rx.borrow());\n        }\n    });\n\n    tx.send(\"updated\".to_string()).unwrap();\n}\n```\n\n### Pattern 3: Async Error Handling\n\n```rust\nuse anyhow::{Context, Result, bail};\nuse thiserror::Error;\n\n#[derive(Error, Debug)]\npub enum ServiceError {\n    #[error(\"Network error: {0}\")]\n    Network(#[from] reqwest::Error),\n\n    #[error(\"Database error: {0}\")]\n    Database(#[from] sqlx::Error),\n\n    #[error(\"Not found: {0}\")]\n    NotFound(String),\n\n    #[error(\"Timeout after {0:?}\")]\n    Timeout(std::time::Duration),\n}\n\n\u002F\u002F Using anyhow for application errors\nasync fn process_request(id: &str) -> Result\u003CResponse> {\n    let data = fetch_data(id)\n        .await\n        .context(\"Failed to fetch data\")?;\n\n    let parsed = parse_response(&data)\n        .context(\"Failed to parse response\")?;\n\n    Ok(parsed)\n}\n\n\u002F\u002F Using custom errors for library code\nasync fn get_user(id: &str) -> Result\u003CUser, ServiceError> {\n    let result = db.query(id).await?;\n\n    match result {\n        Some(user) => Ok(user),\n        None => Err(ServiceError::NotFound(id.to_string())),\n    }\n}\n\n\u002F\u002F Timeout wrapper\nuse tokio::time::timeout;\n\nasync fn with_timeout\u003CT, F>(duration: Duration, future: F) -> Result\u003CT, ServiceError>\nwhere\n    F: std::future::Future\u003COutput = Result\u003CT, ServiceError>>,\n{\n    timeout(duration, future)\n        .await\n        .map_err(|_| ServiceError::Timeout(duration))?\n}\n```\n\n### Pattern 4: Graceful Shutdown\n\n```rust\nuse tokio::signal;\nuse tokio::sync::broadcast;\nuse tokio_util::sync::CancellationToken;\n\nasync fn run_server() -> Result\u003C()> {\n    \u002F\u002F Method 1: CancellationToken\n    let token = CancellationToken::new();\n    let token_clone = token.clone();\n\n    \u002F\u002F Spawn task that respects cancellation\n    tokio::spawn(async move {\n        loop {\n            tokio::select! {\n                _ = token_clone.cancelled() => {\n                    tracing::info!(\"Task shutting down\");\n                    break;\n                }\n                _ = do_work() => {}\n            }\n        }\n    });\n\n    \u002F\u002F Wait for shutdown signal\n    signal::ctrl_c().await?;\n    tracing::info!(\"Shutdown signal received\");\n\n    \u002F\u002F Cancel all tasks\n    token.cancel();\n\n    \u002F\u002F Give tasks time to cleanup\n    tokio::time::sleep(Duration::from_secs(5)).await;\n\n    Ok(())\n}\n\n\u002F\u002F Method 2: Broadcast channel for shutdown\nasync fn run_with_broadcast() -> Result\u003C()> {\n    let (shutdown_tx, _) = broadcast::channel::\u003C()>(1);\n\n    let mut rx = shutdown_tx.subscribe();\n    tokio::spawn(async move {\n        tokio::select! {\n            _ = rx.recv() => {\n                tracing::info!(\"Received shutdown\");\n            }\n            _ = async { loop { do_work().await } } => {}\n        }\n    });\n\n    signal::ctrl_c().await?;\n    let _ = shutdown_tx.send(());\n\n    Ok(())\n}\n```\n\n### Pattern 5: Async Traits\n\n```rust\nuse async_trait::async_trait;\n\n#[async_trait]\npub trait Repository {\n    async fn get(&self, id: &str) -> Result\u003CEntity>;\n    async fn save(&self, entity: &Entity) -> Result\u003C()>;\n    async fn delete(&self, id: &str) -> Result\u003C()>;\n}\n\npub struct PostgresRepository {\n    pool: sqlx::PgPool,\n}\n\n#[async_trait]\nimpl Repository for PostgresRepository {\n    async fn get(&self, id: &str) -> Result\u003CEntity> {\n        sqlx::query_as!(Entity, \"SELECT * FROM entities WHERE id = $1\", id)\n            .fetch_one(&self.pool)\n            .await\n            .map_err(Into::into)\n    }\n\n    async fn save(&self, entity: &Entity) -> Result\u003C()> {\n        sqlx::query!(\n            \"INSERT INTO entities (id, data) VALUES ($1, $2)\n             ON CONFLICT (id) DO UPDATE SET data = $2\",\n            entity.id,\n            entity.data\n        )\n        .execute(&self.pool)\n        .await?;\n        Ok(())\n    }\n\n    async fn delete(&self, id: &str) -> Result\u003C()> {\n        sqlx::query!(\"DELETE FROM entities WHERE id = $1\", id)\n            .execute(&self.pool)\n            .await?;\n        Ok(())\n    }\n}\n\n\u002F\u002F Trait object usage\nasync fn process(repo: &dyn Repository, id: &str) -> Result\u003C()> {\n    let entity = repo.get(id).await?;\n    \u002F\u002F Process...\n    repo.save(&entity).await\n}\n```\n\n### Pattern 6: Streams and Async Iteration\n\n```rust\nuse futures::stream::{self, Stream, StreamExt};\nuse async_stream::stream;\n\n\u002F\u002F Create stream from async iterator\nfn numbers_stream() -> impl Stream\u003CItem = i32> {\n    stream! {\n        for i in 0..10 {\n            tokio::time::sleep(Duration::from_millis(100)).await;\n            yield i;\n        }\n    }\n}\n\n\u002F\u002F Process stream\nasync fn process_stream() {\n    let stream = numbers_stream();\n\n    \u002F\u002F Map and filter\n    let processed: Vec\u003C_> = stream\n        .filter(|n| futures::future::ready(*n % 2 == 0))\n        .map(|n| n * 2)\n        .collect()\n        .await;\n\n    println!(\"{:?}\", processed);\n}\n\n\u002F\u002F Chunked processing\nasync fn process_in_chunks() {\n    let stream = numbers_stream();\n\n    let mut chunks = stream.chunks(3);\n\n    while let Some(chunk) = chunks.next().await {\n        println!(\"Processing chunk: {:?}\", chunk);\n    }\n}\n\n\u002F\u002F Merge multiple streams\nasync fn merge_streams() {\n    let stream1 = numbers_stream();\n    let stream2 = numbers_stream();\n\n    let merged = stream::select(stream1, stream2);\n\n    merged\n        .for_each(|n| async move {\n            println!(\"Got: {}\", n);\n        })\n        .await;\n}\n```\n\n### Pattern 7: Resource Management\n\n```rust\nuse std::sync::Arc;\nuse tokio::sync::{Mutex, RwLock, Semaphore};\n\n\u002F\u002F Shared state with RwLock (prefer for read-heavy)\nstruct Cache {\n    data: RwLock\u003CHashMap\u003CString, String>>,\n}\n\nimpl Cache {\n    async fn get(&self, key: &str) -> Option\u003CString> {\n        self.data.read().await.get(key).cloned()\n    }\n\n    async fn set(&self, key: String, value: String) {\n        self.data.write().await.insert(key, value);\n    }\n}\n\n\u002F\u002F Connection pool with semaphore\nstruct Pool {\n    semaphore: Semaphore,\n    connections: Mutex\u003CVec\u003CConnection>>,\n}\n\nimpl Pool {\n    fn new(size: usize) -> Self {\n        Self {\n            semaphore: Semaphore::new(size),\n            connections: Mutex::new((0..size).map(|_| Connection::new()).collect()),\n        }\n    }\n\n    async fn acquire(&self) -> PooledConnection\u003C'_> {\n        let permit = self.semaphore.acquire().await.unwrap();\n        let conn = self.connections.lock().await.pop().unwrap();\n        PooledConnection { pool: self, conn: Some(conn), _permit: permit }\n    }\n}\n\nstruct PooledConnection\u003C'a> {\n    pool: &'a Pool,\n    conn: Option\u003CConnection>,\n    _permit: tokio::sync::SemaphorePermit\u003C'a>,\n}\n\nimpl Drop for PooledConnection\u003C'_> {\n    fn drop(&mut self) {\n        if let Some(conn) = self.conn.take() {\n            let pool = self.pool;\n            tokio::spawn(async move {\n                pool.connections.lock().await.push(conn);\n            });\n        }\n    }\n}\n```\n\n## Debugging Tips\n\n```rust\n\u002F\u002F Enable tokio-console for runtime debugging\n\u002F\u002F Cargo.toml: tokio = { features = [\"tracing\"] }\n\u002F\u002F Run: RUSTFLAGS=\"--cfg tokio_unstable\" cargo run\n\u002F\u002F Then: tokio-console\n\n\u002F\u002F Instrument async functions\nuse tracing::instrument;\n\n#[instrument(skip(pool))]\nasync fn fetch_user(pool: &PgPool, id: &str) -> Result\u003CUser> {\n    tracing::debug!(\"Fetching user\");\n    \u002F\u002F ...\n}\n\n\u002F\u002F Track task spawning\nlet span = tracing::info_span!(\"worker\", id = %worker_id);\ntokio::spawn(async move {\n    \u002F\u002F Enters span when polled\n}.instrument(span));\n```\n\n## Best Practices\n\n### Do's\n- **Use `tokio::select!`** - For racing futures\n- **Prefer channels** - Over shared state when possible\n- **Use `JoinSet`** - For managing multiple tasks\n- **Instrument with tracing** - For debugging async code\n- **Handle cancellation** - Check `CancellationToken`\n\n### Don'ts\n- **Don't block** - Never use `std::thread::sleep` in async\n- **Don't hold locks across awaits** - Causes deadlocks\n- **Don't spawn unboundedly** - Use semaphores for limits\n- **Don't ignore errors** - Propagate with `?` or log\n- **Don't forget Send bounds** - For spawned futures\n\n## Resources\n\n- [Tokio Tutorial](https:\u002F\u002Ftokio.rs\u002Ftokio\u002Ftutorial)\n- [Async Book](https:\u002F\u002Frust-lang.github.io\u002Fasync-book\u002F)\n- [Tokio Console](https:\u002F\u002Fgithub.com\u002Ftokio-rs\u002Fconsole)\n",{"name":5,"description":7},"main","7850740bd837adb32f0a109ab2af82482196c6f2","skills\u002F_collections\u002Fwshobson-agents\u002Fplugins\u002Fsystems-programming\u002Fskills\u002Frust-async-patterns",1,"https:\u002F\u002Fgithub.com\u002Fshengdabai\u002FTony-Claude-Code-Skills","https:\u002F\u002Fzturnsgo.com","https:\u002F\u002Fgithub.com\u002Fshengdabai","https:\u002F\u002Fzturnsgo.com\u002F","AI × education creator — producer, not consumer. Taught 6,000+ learners; shipping learning tools & daily essays with Claude Code, practicing @xiaolai's way 🥋","2026-11-01 21:28:23",{"source":8,"skillName":5,"commands":59,"prompt":69,"zipAvailable":70},[60,63,66],{"tool":61,"command":62},"npx","npx skills add shengdabai\u002FTony-Claude-Code-Skills --skill rust-async-patterns",{"tool":64,"command":65},"bunx","bunx skills add shengdabai\u002FTony-Claude-Code-Skills --skill rust-async-patterns",{"tool":67,"command":68},"pnpm","pnpm dlx skills add shengdabai\u002FTony-Claude-Code-Skills --skill rust-async-patterns","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002Fshengdabai\u002FTony-Claude-Code-Skills\u002Fblob\u002Fmain\u002Fskills\u002F_collections\u002Fwshobson-agents\u002Fplugins\u002Fsystems-programming\u002Fskills\u002Frust-async-patterns\u002FSKILL.md",true,[],[73,82,90,98,106,114],{"skillNo":74,"name":75,"nameZh":6,"description":76,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":77,"sourceHtmlUrl":78,"categories":79,"keywords":80,"publishedAt":81},"01M73H7XKBHE1ETQDZT94MF9HH","seedance-prompt-en","Write effective prompts for Jimeng Seedance 2.0 multimodal AI video generation. Use when users want to create video prompts using text, images, videos, and audio inputs with the @ reference system. Covers camera movements, effects replication, video extension, editing, music beat-matching, e-commerce ads, short dramas, and educational content.","https:\u002F\u002Fgithub.com\u002Fshengdabai\u002FTony-Claude-Code-Skills\u002Fblob\u002Fmain\u002Fskills\u002Fseedance-prompt-en\u002FLICENSE","https:\u002F\u002Fgithub.com\u002Fshengdabai\u002FTony-Claude-Code-Skills\u002Fblob\u002Fmain\u002Fskills\u002Fseedance-prompt-en\u002FSKILL.md",[],[],"2026-11-11 15:11:14",{"skillNo":83,"name":84,"nameZh":6,"description":85,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":86,"sourceHtmlUrl":87,"categories":88,"keywords":89,"publishedAt":81},"01M73GRE9998Q1DZWC71N41JWG","onepage-pdf","Convert an HTML page into a single continuous-page PDF (one tall page, no pagination breaks), preserving desktop layout, backgrounds and selectable text. Use when the user asks to turn an HTML file\u002Freport\u002Fproposal into a \"single-page PDF\", \"long PDF\", \"不分页 PDF\", \"单页 PDF\", \"长图式 PDF\", or complains that an HTML-to-PDF export breaks into pages or cuts content. Supports optional string redaction with leak verification.","https:\u002F\u002Fgithub.com\u002Fshengdabai\u002FTony-Claude-Code-Skills\u002Fblob\u002Fmain\u002Fskills\u002Fonepage-pdf\u002FLICENSE","https:\u002F\u002Fgithub.com\u002Fshengdabai\u002FTony-Claude-Code-Skills\u002Fblob\u002Fmain\u002Fskills\u002Fonepage-pdf\u002FSKILL.md",[],[],{"skillNo":91,"name":92,"nameZh":6,"description":93,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":94,"sourceHtmlUrl":95,"categories":96,"keywords":97,"publishedAt":81},"01M73GQG1KZDADVPV3MHAT1J5A","native-feel-cross-platform-desktop","Use when the user is designing, prototyping, or rewriting a desktop app that must run on multiple OSes (macOS + Windows, optionally Linux) AND feel indistinguishable from a native app to its users — fast launch, native windowing, native input handling, native materials. Trigger words include \"cross-platform desktop\", \"Electron alternative\", \"Tauri vs native\", \"WebView wrapper\", \"near-native performance\", \"Raycast architecture\", \"WebKit\u002FWebView2 quirks\", \"WKWebView\", \"system tray app\", \"global hotkey app\", \"launcher app\". Do NOT trigger this skill for pure web apps, pure mobile apps, or for greenfield projects that have no native-feel requirement.","https:\u002F\u002Fgithub.com\u002Fshengdabai\u002FTony-Claude-Code-Skills\u002Fblob\u002Fmain\u002Fskills\u002Fnative-feel-cross-platform-desktop\u002FLICENSE","https:\u002F\u002Fgithub.com\u002Fshengdabai\u002FTony-Claude-Code-Skills\u002Fblob\u002Fmain\u002Fskills\u002Fnative-feel-cross-platform-desktop\u002FSKILL.md",[],[],{"skillNo":99,"name":100,"nameZh":6,"description":101,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":102,"sourceHtmlUrl":103,"categories":104,"keywords":105,"publishedAt":81},"01M73G87PDNSMKG2FHWCYER6N8","gstack","Router for the gstack skill suite. (gstack)","https:\u002F\u002Fgithub.com\u002Fshengdabai\u002FTony-Claude-Code-Skills\u002Fblob\u002Fmain\u002Fskills\u002Fgstack\u002FLICENSE","https:\u002F\u002Fgithub.com\u002Fshengdabai\u002FTony-Claude-Code-Skills\u002Fblob\u002Fmain\u002Fskills\u002Fgstack\u002FSKILL.md",[],[],{"skillNo":107,"name":108,"nameZh":6,"description":109,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":110,"sourceHtmlUrl":111,"categories":112,"keywords":113,"publishedAt":81},"01M73G3EAQWKCM8DB8D0N0QSVG","fireworks-tech-graph","Use when the user wants to create any technical diagram - architecture, data flow, flowchart, sequence, agent\u002Fmemory, or concept map - and export as SVG+PNG. Trigger on: \"画图\" \"帮我画\" \"生成图\" \"做个图\" \"架构图\" \"流程图\" \"可视化一下\" \"出图\" \"generate diagram\" \"draw diagram\" \"visualize\" or any system\u002Fflow description the user wants illustrated.","https:\u002F\u002Fgithub.com\u002Fshengdabai\u002FTony-Claude-Code-Skills\u002Fblob\u002Fmain\u002Fskills\u002Ffireworks-tech-graph\u002FLICENSE","https:\u002F\u002Fgithub.com\u002Fshengdabai\u002FTony-Claude-Code-Skills\u002Fblob\u002Fmain\u002Fskills\u002Ffireworks-tech-graph\u002FSKILL.md",[],[],{"skillNo":115,"name":116,"nameZh":6,"description":117,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":118,"categories":119,"keywords":120,"publishedAt":81},"01M73G086AXAH9DW1H5G5N3CPB","dbs-video-extract","接收抖音、小红书、微信视频号等短视频链接或分享文案，查询作品／账号数据并提取语音文字稿，按作者和标题归档为 Markdown。用户希望完整解析短视频、取得数据或文字稿时使用；运行前检查 TikHub 与轻抖使用凭证，缺少时用新手能理解的方式引导购买和安全配置。","https:\u002F\u002Fgithub.com\u002Fshengdabai\u002FTony-Claude-Code-Skills\u002Fblob\u002Fmain\u002Fskills\u002Fdbs-video-extract\u002FSKILL.md",[],[]]