concurrency-patterns

SKILL.md

Concurrency Patterns

Table of Contents

Overview

When to Use

Quick Start

Reference Guides

Best Practices

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:

Guide
Contents

Promise Pool (TypeScript)
Promise Pool (TypeScript)

Mutex and Semaphore (TypeScript)
Mutex and Semaphore (TypeScript)

Worker Pool (Node.js)
Worker Pool (Node.js)

Python Threading Patterns
Python 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

1d:[