Concurrency Patterns

This is your reference for implementing thread-safe concurrent code across JavaScript, Python, and simulated Go patterns. It covers promise pools, mutexes, semaphores, worker pools, and async/await coordination with working examples in each language. The promise pool and mutex implementations are solid starting points if you need to limit concurrency or prevent race conditions. Most useful when you're building systems that do parallel processing or need to coordinate multiple async operations without hammering resources. The guides are implementation-focused rather than theory-heavy, which means you can copy and adapt quickly. Just remember that concurrent code needs real testing under load, not just unit tests.

skills.sh installs: 476
GitHub stars: 379
last updated: Aug 21, 2026

View on GitHub

Install

$ npx -y skills add aj-geddes/useful-ai-prompts --skill concurrency-patterns --agent claude-code

Installs into .claude/skills of the current project.

Files

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--;
    }
  }

SKILL.md on GitHub