mcpField
R
rust-concurrency-primitives

rust-concurrency-primitives

github.com/lvtd-llcDevelopment161 installsUpdated 8w ago
Repository

About rust-concurrency-primitives

A skill for designing and reviewing thread-based concurrency in Rust. It helps Rust developers choose ownership, channels, locks, initialization primitives, and atomics according to the coordination need, with safety and testing guidance.

Key features

  1. 01Classifies concurrency patterns
  2. 02Guides primitive selection
  3. 03Ownership and synchronization rules
  4. 04Locking and atomic safety guidance
  5. 05Deterministic concurrency test advice

Use cases

  1. 01Designing a producer-consumer pipeline
  2. 02Sharing state across Rust threads
  3. 03Reviewing deadlock-prone code
  4. 04Testing cancellation and shutdown behavior

Install

Copy the command and run it in a terminal.

$npx skills add https://github.com/lvtd-llc/skills --skill rust-concurrency-primitives

After installing, type/rust-concurrency-primitivesin Claude Code to confirm it loaded.

Bundled filesagents/openai.yamlreferences/threading-shared-state.md

Details

From the project README

Rust Concurrency Primitives

Use this skill to design thread-based Rust concurrency with explicit ownership, sharing, and synchronization. Prefer the simplest primitive that matches the coordination requirement before adding shared mutable state.

Core Workflow

  1. Classify the work: independent fork-join, producer/consumer pipeline, shared state, one-time initialization, or low-level atomic coordination.
  2. Prefer owned data per thread. Add shared ownership only when data must be observed or mutated by multiple threads.
  3. Use std::thread::scope when child threads can borrow stack data and must finish before the function returns.
  4. Use channels for ownership transfer and pipelines. Use Arc<Mutex<T>> or Arc<RwLock<T>> only when shared state is the clearer model.
  5. Keep lock scopes short and never call user-controlled or blocking code while holding a lock unless that is the invariant being protected.
  6. Use OnceLock or LazyLock for thread-safe one-time initialization instead of ad hoc global mutable state.
  7. Treat atomics as a specialized tool. Use SeqCst by default until a weaker ordering is justified and documented.

Primitive Selection

Read references/threading-shared-state.md before introducing a new shared state primitive or reviewing deadlock-prone code.

NeedPrimitive
Borrow local data into short-lived threadsstd::thread::scope
Transfer work or resultsstd::sync::mpsc or project channel crate
Shared read/write stateArc<Mutex<T>>
Many readers, rare writersArc<RwLock<T>>
Wait for condition changesCondvar with Mutex
One-time global initializationLazyLock or OnceLock
Counters, flags, lock-free coordinationstd::sync::atomic

Safety And Review Rules

  • Require Send for values crossing thread boundaries and Sync for shared references used from multiple threads.
  • Decide whether poisoning should propagate panic or recover with PoisonError::into_inner.
  • Establish a lock ordering when more than one lock can be acquired.
  • Prefer Arc::clone(&value) over value.clone() when the cloned value is an ownership handle and readability matters.
  • Use Rayon for data parallel iteration when the problem is pure CPU data parallelism and the project already accepts that dependency.

Tests

  • Add deterministic tests around final state, message counts, and shutdown.
  • Use barriers, channels, or scoped threads to coordinate tests; avoid sleeps.
  • Add at least one test for panic, dropped sender/receiver, or cancellation behavior when the code depends on it.

Comments

Markdown supported