M07 Concurrency
Diagnose Rust Send/Sync, async, and locking errors and pick the right concurrency model before patching code.
Overview
M07 Concurrency is an agent skill for the Build phase that guides Rust async, threads, and Send/Sync decisions when concurrency compiler errors or design questions appear.
Install
npx skills add https://github.com/zhanghandong/rust-skills --skill m07-concurrencyWhat is this skill?
- Frames every fix around workload type: CPU-bound (threads/rayon) versus I/O-bound (async/tokio).
- Maps compiler errors E0277 Send/Sync to design questions instead of blanket Mutex wrapping.
- Documents sharing patterns: message passing, Arc<T>, Arc<Mutex<T>>, Arc<RwLock<T>>.
- Covers async pitfalls including non-Send futures and when spawn_local is appropriate.
- Includes deadlock and race-condition prompts tied to locking design, not lock reorder hacks.
- Error-to-design table for E0277 Send/Sync and Future not Send
Adoption & trust: 803 installs on skills.sh; 1.2k GitHub stars; 3/3 security scanners passed (skills.sh audits).
What problem does it solve?
Your Rust build fails with Send/Sync or async errors and the agent keeps adding Mutex bounds without clarifying CPU vs I/O workload or sharing needs.
Who is it for?
Solo builders maintaining Rust backends or CLIs who hit E0277, tokio spawn issues, or deadlock warnings during agent-assisted refactors.
Skip if: Greenfield Rust tutorials with no errors yet, or front-end-only JavaScript concurrency—this skill is Rust compiler-error and systems oriented.
When should I use this skill?
CRITICAL concurrency/async work: E0277 Send Sync, cannot be sent between threads, thread, spawn, channel, mpsc, Mutex, RwLock, Atomic, async, await, Future, tokio, deadlock, race condition, or 并发/线程/异步/死锁.
What do I get? / Deliverables
You get a concurrency model choice (threads, async, channels, Arc patterns) grounded in workload and safety requirements before code changes.
- Documented concurrency model recommendation
- Send/Sync-aware refactor plan aligned to workload type
Recommended Skills
Journey fit
How it compares
Use as layered diagnostic doctrine alongside generic “fix the error” chat, not as a one-shot code generator.
Common Questions / FAQ
Who is m07-concurrency for?
Developers using AI agents on Rust codebases who need structured concurrency and async guidance when compiler errors or 并发/线程/异步 questions appear.
When should I use m07-concurrency?
During Build on backend Rust work whenever you see E0277 Send/Sync, thread spawn, channel/mpsc usage, Mutex/RwLock design, tokio/async await issues, or deadlock and race concerns.
Is m07-concurrency safe to install?
The skill is instructional markdown; confirm trust via the Security Audits panel on this page and your skills.sh source before enabling unrelated shell or network tools.
SKILL.md
READMESKILL.md - M07 Concurrency
# Concurrency > **Layer 1: Language Mechanics** ## Core Question **Is this CPU-bound or I/O-bound, and what's the sharing model?** Before choosing concurrency primitives: - What's the workload type? - What data needs to be shared? - What's the thread safety requirement? --- ## Error → Design Question | Error | Don't Just Say | Ask Instead | |-------|----------------|-------------| | E0277 Send | "Add Send bound" | Should this type cross threads? | | E0277 Sync | "Wrap in Mutex" | Is shared access really needed? | | Future not Send | "Use spawn_local" | Is async the right choice? | | Deadlock | "Reorder locks" | Is the locking design correct? | --- ## Thinking Prompt Before adding concurrency: 1. **What's the workload?** - CPU-bound → threads (std::thread, rayon) - I/O-bound → async (tokio, async-std) - Mixed → hybrid approach 2. **What's the sharing model?** - No sharing → message passing (channels) - Immutable sharing → Arc<T> - Mutable sharing → Arc<Mutex<T>> or Arc<RwLock<T>> 3. **What are the Send/Sync requirements?** - Cross-thread ownership → Send - Cross-thread references → Sync - Single-thread async → spawn_local --- ## Trace Up ↑ (MANDATORY) **CRITICAL**: Don't just fix the error. Trace UP to find domain constraints. ### Domain Detection Table | Context Keywords | Load Domain Skill | Key Constraint | |-----------------|-------------------|----------------| | Web API, HTTP, axum, actix, handler | **domain-web** | Handlers run on any thread | | 交易, 支付, trading, payment | **domain-fintech** | Audit + thread safety | | gRPC, kubernetes, microservice | **domain-cloud-native** | Distributed tracing | | CLI, terminal, clap | **domain-cli** | Usually single-thread OK | ### Example: Web API + Rc Error ``` "Rc cannot be sent between threads" in Web API context ↑ DETECT: "Web API" → Load domain-web ↑ FIND: domain-web says "Shared state must be thread-safe" ↑ FIND: domain-web says "Rc in state" is Common Mistake ↓ DESIGN: Use Arc<T> with State extractor ↓ IMPL: axum::extract::State<Arc<AppConfig>> ``` ### Generic Trace ``` "Send not satisfied for my type" ↑ Ask: What domain is this? Load domain-* skill ↑ Ask: Does this type need to cross thread boundaries? ↑ Check: m09-domain (is the data model correct?) ``` | Situation | Trace To | Question | |-----------|----------|----------| | Send/Sync in Web | **domain-web** | What's the state management pattern? | | Send/Sync in CLI | **domain-cli** | Is multi-thread really needed? | | Mutex vs channels | m09-domain | Shared state or message passing? | | Async vs threads | m10-performance | What's the workload profile? | --- ## Trace Down ↓ From design to implementation: ``` "Need parallelism for CPU work" ↓ Use: std::thread or rayon "Need concurrency for I/O" ↓ Use: async/await with tokio "Need to share immutable data across threads" ↓ Use: Arc<T> "Need to share mutable data across threads" ↓ Use: Arc<Mutex<T>> or Arc<RwLock<T>> ↓ Or: channels for message passing "Need simple atomic operations" ↓ Use: AtomicBool, AtomicUsize, etc. ``` --- ## Send/Sync Markers | Marker | Meaning | Example | |--------|---------|---------| | `Send` | Can transfer ownership between threads | Most types | | `Sync` | Can share references between threads | `Arc<T>` | | `!Send` | Must stay on one thread | `Rc<T>` | | `!Sync` | No shared refs across threads | `RefCell<T>` | ## Quick Reference | Pattern | Thread-Safe | Blocking | Use When | |---------|-------------|----------|----------| | `std::thread` | Yes | Yes | CPU-bound parallelism | | `async/await` | Yes | No | I/O-bound concurrency | | `Mutex<T>` | Yes | Yes