Concurrency Patterns Skill

Concurrency Patterns

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

Agent Skills: Concurrency Patterns

Install this agent skill to your local

Skill Files