Promise Pool

Promise Pool - Problem

JavaScript Medium

Given an array of asynchronous functions functions and a pool limit n, return an asynchronous function promisePool. It should return a promise that resolves when all the input functions resolve.

Pool limit is defined as the maximum number promises that can be pending at once. promisePool should begin execution of as many functions as possible and continue executing new functions when old promises resolve.

promisePool should execute functions[i] then functions[i + 1] then functions[i + 2], etc. When the last promise resolves, promisePool should also resolve.

For example, if n = 1, promisePool will execute one function at a time in series. However, if n = 2, it first executes two functions. When either of the two functions resolve, a 3rd function should be executed (if available), and so on until there are no functions left to execute.

You can assume all functions never reject. It is acceptable for promisePool to return a promise that resolves any value.

Input & Output

Example 1 — Pool Limit 2

$ Input: functions = [() => new Promise(res => setTimeout(res, 300)), () => new Promise(res => setTimeout(res, 400)), () => new Promise(res => setTimeout(res, 200))], n = 2

› Output: Promise that resolves after ~500ms

💡 Note: First 2 functions start immediately. Function 1 (300ms) and function 2 (400ms) run concurrently. After 300ms, function 1 completes and function 3 (200ms) starts. Total time: max(300, 400) + 200 = 500ms.

Example 2 — Pool Limit 1

$ Input: functions = [() => new Promise(res => setTimeout(res, 100)), () => new Promise(res => setTimeout(res, 200))], n = 1

› Output: Promise that resolves after 300ms

💡 Note: With n=1, functions execute sequentially: first function (100ms), then second function (200ms). Total: 100 + 200 = 300ms.

Example 3 — Empty Array

$ Input: functions = [], n = 3

› Output: Promise that resolves immediately

💡 Note: No functions to execute, so the pool resolves immediately.

Constraints

0 ≤ functions.length ≤ 10
1 ≤ n ≤ 10

Visualization

Tap to expand

Asked in

M Meta 25 G Google 20

The key insight is to maintain exactly n concurrent promises using a queue system. The optimal approach uses Promise.race() to wait for any promise to complete, then immediately starts the next function. Time: O(T/n) where T is total execution time, Space: O(n) for tracking active promises.

Common Approaches

✓ Promise Pool with Queue

⏱️ Time: O(T/n) Space: O(n)

Use a queue to manage function execution, keeping exactly n promises running concurrently. When any promise resolves, immediately start the next function from the queue.

Sequential Execution

⏱️ Time: O(T) Space: O(1)

Execute functions sequentially using await, completely ignoring the pool limit n. This is the simplest approach but doesn't utilize concurrency.

Promise Pool with Queue — Algorithm Steps

Step 1: Start first n functions concurrently
Step 2: When any promise resolves, start next function
Step 3: Continue until all functions complete

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial

Start first n functions

Replace

Replace completed with new functions

Complete

Finish when all done

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char* solution(char** functions, int funcCount, int n) {
    static char result[] = "promisePool function";
    return result;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    fgets(line, sizeof(line), stdin);
    int n = atoi(line);
    
    char** functions = NULL;
    char* result = solution(functions, 0, n);
    printf("%s\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(T/n)

T is total execution time, divided by n concurrent executions

✓ Linear Growth

Space Complexity

O(n)

Queue and promise tracking arrays store at most n items

✓ Linear Space

12.0K Views

Medium Frequency

~25 min Avg. Time

450 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Promise Pool with Queue — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler