version: "1.0.1" name: concurrency-patterns description: > Implement thread-safe code, mutexes, semaphores, async/await patterns, and concurrent data structures. Use when handling parallel operations, race conditions, or building high-performance concurrent systems.

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:

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