back
loading skill details...
>
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:[don't have the plugin yet? install it then click "run inline in claude" again.