Concurrency Patterns

Concurrency patterns help manage shared state and coordinate between multiple execution threads.

Thread-Safe Singleton

// Double-checked locking (conceptual - JS is single-threaded but useful for understanding)
class ThreadSafeSingleton {
  private static instance: ThreadSafeSingleton | null = null;
  private static lock: boolean = false;

  private constructor() {}

  static getInstance(): ThreadSafeSingleton {
    if (!ThreadSafeSingleton.instance) {
      // In multi-threaded env, would use actual lock
      if (!ThreadSafeSingleton.lock) {
        ThreadSafeSingleton.lock = true;
        if (!ThreadSafeSingleton.instance) {
          ThreadSafeSingleton.instance = new ThreadSafeSingleton();
        }
        ThreadSafeSingleton.lock = false;
      }
    }
    return ThreadSafeSingleton.instance!;
  }
}

// Better: Initialization-on-demand holder idiom
class SafeSingleton {
  private static readonly INSTANCE = new SafeSingleton();

  private constructor() {}

  static getInstance(): SafeSingleton {
    return SafeSingleton.INSTANCE;
  }
}

Producer-Consumer Pattern

class BoundedQueue {
  private queue: T[] = [];
  private readonly maxSize: number;
  private waitingProducers: Array<() => void> = [];
  private waitingConsumers: Array<(item: T) => void> = [];

  constructor(maxSize: number) {
    this.maxSize = maxSize;
  }

  async produce(item: T): Promise {
    // Wait if queue is full
    while (this.queue.length >= this.maxSize) {
      await new Promise(resolve => {
        this.waitingProducers.push(resolve);
      });
    }

    this.queue.push(item);

    // Notify waiting consumers
    const consumer = this.waitingConsumers.shift();
    if (consumer) {
      consumer(this.queue.shift()!);
    }
  }

  async consume(): Promise {
    // Wait if queue is empty
    if (this.queue.length === 0) {
      return new Promise(resolve => {
        this.waitingConsumers.push(resolve);
      });
    }

    const item = this.queue.shift()!;

    // Notify waiting producers
    const producer = this.waitingProducers.shift();
    if (producer) {
      producer();
    }

    return item;
  }
}

// Usage
const queue = new BoundedQueue(10);

// Producer
async function producer(id: number) {
  while (true) {
    const task = await generateTask();
    await queue.produce(task);
    console.log(`Producer ${id} added task`);
  }
}

// Consumer
async function consumer(id: number) {
  while (true) {
    const task = await queue.consume();
    console.log(`Consumer ${id} processing task`);
    await processTask(task);
  }
}

Read-Write Lock Pattern

class ReadWriteLock {
  private readers: number = 0;
  private writer: boolean = false;
  private waitingWriters: Array<() => void> = [];
  private waitingReaders: Array<() => void> = [];

  async acquireReadLock(): Promise {
    // Wait if there's an active writer or waiting writers
    while (this.writer || this.waitingWriters.length > 0) {
      await new Promise(resolve => {
        this.waitingReaders.push(resolve);
      });
    }
    this.readers++;
  }

  releaseReadLock(): void {
    this.readers--;
    if (this.readers === 0) {
      // Notify waiting writer
      const writer = this.waitingWriters.shift();
      if (writer) writer();
    }
  }

  async acquireWriteLock(): Promise {
    // Wait if there are active readers or writer
    while (this.readers > 0 || this.writer) {
      await new Promise(resolve => {
        this.waitingWriters.push(resolve);
      });
    }
    this.writer = true;
  }

  releaseWriteLock(): void {
    this.writer = false;
    // Notify all waiting readers or one writer
    if (this.waitingReaders.length > 0) {
      const readers = [...this.waitingReaders];
      this.waitingReaders = [];
      readers.forEach(resolve => resolve());
    } else {
      const writer = this.waitingWriters.shift();
      if (writer) writer();
    }
  }
}

// Thread-safe cache with RW lock
class ThreadSafeCache {
  private cache: Map = new Map();
  private lock: ReadWriteLock = new ReadWriteLock();

  async get(key: K): Promise {
    await this.lock.acquireReadLock();
    try {
      return this.cache.get(key);
    } finally {
      this.lock.releaseReadLock();
    }
  }

  async set(key: K, value: V): Promise {
    await this.lock.acquireWriteLock();
    try {
      this.cache.set(key, value);
    } finally {
      this.lock.releaseWriteLock();
    }
  }
}