ac-async-and-concurrency
Designing code that does more than one thing at a time without races: shared mutable state and the primitives that protect it, async runtimes and the executor model, cancellation checkpoints and what never runs, structured concurrency and scope lifetime, ordering guarantees and happens-before, message passing and actor ownership as the alternative to locks, testing concurrency deterministically, and the written concurrency record. It explains how concurrent code behaves and fails; it never recommends a runtime and never promises a speedup. Use when asking "race condition", "deadlock", "async await", "callback", "coroutine", "cancellation", "structured concurrency", "happens before", "atomicity", "lock ordering", "why does it fail only sometimes", "shared mutable state". Not for distributed state and replication (ac-distributed-state-and-replication), not for resilience budgets around calls (ac-resilience-budgets), not for workflow orchestration (ac-durable-execution).
- License 许可
- MIT
- 最近更新
- 2026-11-15
- Stars
- ★ 81
- Forks
- 17
01 前言 Front Matter
- name
- ac-async-and-concurrency
- status
- seedling
- license
- MIT
- metadata
- { "domain": "software-engineering" }
- description
- Designing code that does more than one thing at a time without races: shared mutable state and the primitives that protect it, async runtimes and the executor model, cancellation checkpoints and what never runs, structured concurrency and scope lifetime, ordering guarantees and happens-before, message passing and actor ownership as the alternative to locks, testing concurrency deterministically, and the written concurrency record. It explains how concurrent code behaves and fails; it never recommends a runtime and never promises a speedup. Use when asking "race condition", "deadlock", "async await", "callback", "coroutine", "cancellation", "structured concurrency", "happens before", "atomicity", "lock ordering", "why does it fail only sometimes", "shared mutable state". Not for distributed state and replication (ac-distributed-state-and-replication), not for resilience budgets around calls (ac-resilience-budgets), not for workflow orchestration (ac-durable-execution).
02 资源文件 11
- 许可证LICENSE1.0 KB
- 参考文档SOURCE.md380 B
- 参考文档subskills/async-api-design.md3.2 KB
- 参考文档subskills/async-runtimes.md3.2 KB
- 参考文档subskills/cancellation.md3.2 KB
- 参考文档subskills/concurrency-record.md3.3 KB
- 参考文档subskills/concurrency-testing.md3.2 KB
- 参考文档subskills/lock-ordering-and-deadlock.md3.0 KB
- 参考文档subskills/message-passing-and-actors.md3.4 KB
- 参考文档subskills/shared-state-and-primitives.md3.3 KB
- 参考文档TRUST.auto.yaml2.2 KB
03 SKILL.md 正文
Async and concurrency
Overview
Concurrency bugs are distinguished from other bugs by their reproducibility: a race fails once in ten thousand runs, on the machine with the different core count, during the demo. The cause is rarely exotic — two threads of execution touching shared mutable state without an agreed ordering — and the cure is rarely cleverness: it is making the sharing and the ordering explicit, then testing both under pressure.
This skill is the single-machine craft: what shared state is, what the synchronisation primitives actually guarantee, how async runtimes schedule and what that implies, what cancellation means and what it silently skips, how to test nondeterministic code, and how to write down a concurrency design so a reviewer can reason about it. Distributed agreement and retry budgets are other skills.
Primary sources: https://martinfowler.com/ and https://dl.acm.org/.
When to use
- When code runs tasks concurrently and shares state or resources.
- When a failure is intermittent, timing-dependent, or load-dependent.
- When designing or reviewing an async API, a cancellation path, or pooled resources.
When NOT to use
- For replicated data and quorum consistency (use ac-distributed-state-and-replication).
- For timeouts, retries, and circuit breakers around calls (use ac-resilience-budgets).
- For durable workflows and saga orchestration (use ac-durable-execution).
Subskill Index
| Leaf | Domain segment | Scope (one line) |
|---|---|---|
subskills/shared-state-and-primitives.md |
software-engineering/shared-state-and-primitives |
What shared mutable state is, and what locks and atomics actually provide. |
subskills/async-runtimes.md |
software-engineering/async-runtimes |
Executors, scheduling, and the assumptions async breaks. |
subskills/cancellation.md |
software-engineering/cancellation |
What cancellation means, what it skips, and designing to be cancelled. |
subskills/lock-ordering-and-deadlock.md |
software-engineering/lock-ordering-and-deadlock |
Acquiring in order, timing out, and why deadlock is a design error. |
subskills/concurrency-testing.md |
software-engineering/concurrency-testing |
Making races reproducible: stress, interleaving injection, and model checks. |
subskills/async-api-design.md |
software-engineering/async-api-design |
Futures, callbacks, and the semantics an async interface must state. |
subskills/message-passing-and-actors.md |
software-engineering/message-passing-and-actors |
Actors, mailboxes, ownership by isolation, and where message passing beats locks. |
subskills/concurrency-record.md |
software-engineering/concurrency-record |
The written record: shared state, orderings, cancellation, and blast radius. |
Status and honest limits
Concurrency correctness is a proof about all interleavings, and tests exercise a vanishing subset of them; a stress run that passes a million iterations has not examined the one interleaving that deadlocks. The mitigations — explicit state ownership, documented orderings, bounded pools, and cancellation semantics — reduce the space rather than close it, and nothing here recommends a runtime or promises a speedup, because most parallelism gains are bought by waiting, not by racing.
04 同仓库更多 Skills
troves
Deposit and withdraw from Troves DeFi yield vault strategies on Starknet. View available strategies, check positions, and manage vault deposits. Use this skill when the user mentions Troves, vault, yield vault, DeFi vault, strategy, yield farming, vault deposit, vault withdraw, earning yield through vaults, passive yield strategies, or wants to deposit into or withdraw from a yield strategy — even if they don't say "Troves" explicitly.
trade
Swap tokens on Starknet via Fibrous DEX aggregator. Supports per-provider selection (avnu, ekubo, or auto to race all). Use this skill when the user wants to swap, exchange, trade, convert, buy, or sell one token for another on Starknet. Also use when the user asks about token prices, exchange rates, DEX routing, best swap route, or wants to check how much they would receive for a given amount — even if they don't explicitly say "swap".
staking
Stake, unstake, claim, and compound rewards for STRK, WBTC, tBTC, SolvBTC, and LBTC on Starknet. View validators, pools, and staking positions. Use this skill when the user mentions staking, delegating, validators, staking pools, rewards, compounding, unstaking, earning yield, passive income on crypto, or wants to earn on their STRK or BTC tokens — even if they don't say "stake" explicitly.
send
Send STRK, ETH, or any ERC-20 token to a Starknet address. Supports simulation (dry-run) before execution. Use this skill when the user wants to send, transfer, pay, tip, or move tokens to another wallet address on Starknet. Also trigger when the user mentions sending funds to someone, making a payment, transferring assets, or moving crypto to a specific address — even if they just say "pay 10 STRK to 0x...".
portfolio
View a comprehensive DeFi portfolio dashboard and optimize portfolio allocation via automated rebalancing. Use this skill when the user wants an overview, summary, dashboard, total value, net worth, portfolio rebalancing, target allocation, or wants to see all their DeFi positions across Starknet at once. Also trigger when the user asks "what do I have", "show me everything", "how much am I worth", "my positions", "my investments", "rebalance my portfolio", "I want 50% ETH", "optimize my holdings", or any request for a holistic view of their Starknet holdings — even if they don't explicitly say "portfolio".
multi-swap
Execute multiple token swaps in a single Starknet transaction via Fibrous (default). Supports per-provider selection (avnu, ekubo, or auto to race all). Supports 2-3 swap pairs bundled into one multicall. Use this skill when the user wants to swap multiple token pairs at once, do batch swaps, execute several trades simultaneously, perform parallel swaps, or do bulk trading in one transaction. Also trigger when the user mentions "two swaps", "three swaps", "swap X and Y at the same time", or wants to convert multiple tokens in a single call.