mcpField
C
concurrency-patterns

concurrency-patterns

github.com/aj-geddesDevelopment373472 installsUpdated 34w ago
Repository

About concurrency-patterns

A skill for implementing safe concurrent code with synchronization primitives and parallel execution patterns. Its references include TypeScript, Node.js, Python, and Go-style examples.

Key features

  1. 01Promise pool patterns in TypeScript
  2. 02Mutex and semaphore guidance
  3. 03Node.js worker pool patterns
  4. 04Python threading and asyncio patterns
  5. 05Go-style channel simulation
  6. 06Concurrency safety practices

Use cases

  1. 01Limiting parallel task execution
  2. 02Coordinating concurrent workers
  3. 03Preventing race conditions on shared state
  4. 04Applying async patterns in Python

Install

Copy the command and run it in a terminal.

$npx skills add https://github.com/aj-geddes/useful-ai-prompts --skill concurrency-patterns

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

Bundled files

References and scripts installed along with SKILL.md.

references/
async-patterns-python-asyncio.md
go-style-channels-simulation.md
mutex-and-semaphore-typescript.md
promise-pool-typescript.md
python-threading-patterns.md
worker-pool-nodejs.md
scripts/
validate-api.sh
templates/
api-scaffold.yaml

Details

From the project README

Concurrency Patterns

Table of Contents

Overview

Implement safe concurrent code using proper synchronization primitives and patterns for parallel execution.

When to Use

  • Multi-threaded applications
  • Parallel data processing
  • Race condition prevention
  • Resource pooling
  • Task coordination
  • High-performance systems
  • Async operations
  • Worker pools

Quick Start

Minimal working example:

class PromisePool {
  private queue: Array<() => Promise<any>> = [];
  private active = 0;

  constructor(private concurrency: number) {}

  async add<T>(fn: () => Promise<T>): Promise<T> {
    while (this.active >= this.concurrency) {
      await this.waitForSlot();
    }

    this.active++;

    try {
      return await fn();
    } finally {
      this.active--;
    }
  }

  private async waitForSlot(): Promise<void> {
    return new Promise((resolve) => {
      const checkSlot = () => {
        if (this.active < this.concurrency) {
          resolve();
// ... (see reference guides for full implementation)

Reference Guides

Detailed implementations in the references/ directory:

GuideContents
Promise Pool (TypeScript)Promise Pool (TypeScript)
Mutex and Semaphore (TypeScript)Mutex and Semaphore (TypeScript)
Worker Pool (Node.js)Worker Pool (Node.js)
Python Threading PatternsPython Threading Patterns
Async Patterns (Python asyncio)Async Patterns (Python asyncio)
Go-Style Channels (Simulation)Go-Style Channels (Simulation)

Best Practices

✅ DO
  • Use proper synchronization primitives
  • Limit concurrency to avoid resource exhaustion
  • Handle errors in concurrent operations
  • Use immutable data when possible
  • Test concurrent code thoroughly
  • Profile concurrent performance
  • Document thread-safety guarantees
❌ DON'T
  • Share mutable state without synchronization
  • Use sleep/polling for coordination
  • Create unlimited threads/workers
  • Ignore race conditions
  • Block event loops in async code
  • Forget to clean up resources

Comments

Markdown supported