Task Runner with Concurrency Limit

Approach Tips

**Core Pattern:** Queue + active counter + drain loop. ```javascript class TaskRunner { constructor(maxConcurrency) { this.max = maxConcurrency; this.running = 0; this.queue = []; } push(task) { return new Promise((resolve, reject) => { this.queue.push({ task, resolve, reject }); this._drain(); }); } _drain() { while (this.running < this.max && this.queue.length > 0) { const { task, resolve, reject } = this.queue.shift(); this.running++; task() .then(resolve) .catch(reject) .finally(() => { this.running--; this._drain(); // process next queued task }); } } } ``` **Why `.finally()` is critical:** If a task rejects and you only have `.then()`, the running count never decrements and the runner stalls. `.finally()` runs on both resolve and reject. **What interviewers look for:** - Clean separation between queuing and execution - Correct handling of both resolved and rejected promises - Understanding that `_drain` is called both on `push()` AND on task completion - No race conditions (JS is single-threaded, so no mutex needed — but explain why) **Follow-up questions:** - Add a `waitForAll()` method that resolves when all queued tasks complete - Add task priority (higher priority tasks jump the queue) - Add cancellation support (cancel a queued task before it starts) - What if you need this in a multi-threaded language? (Now you need locks) **Common mistakes:** - Forgetting to handle rejections → runner freezes - Calling `_drain` only in `push` but not on completion → tasks stay queued forever - Using `await` instead of `.then()` inside `_drain` → serializes execution