Promise Pool - Practice Coding Problems

Promise Pool - Problem

JavaScript Medium

Promise Pool is a critical concurrency control pattern in JavaScript that manages the execution of asynchronous operations with a limited pool of concurrent promises.

You're given an array of functions (asynchronous functions that return promises) and a pool limit n. Your task is to implement a promisePool function that:

🎯 Goal: Execute all functions while maintaining at most n concurrent promises at any time

Key Requirements:
• Execute functions in order: functions[0], then functions[1], then functions[2], etc.
• Maintain exactly n concurrent promises (when possible)
• When a promise resolves, immediately start the next available function
• Return a promise that resolves when ALL functions complete

Example: If n = 2 and you have 5 functions:
1. Start functions[0] and functions[1] simultaneously
2. When either completes, start functions[2]
3. When another completes, start functions[3]
4. Continue until all functions are executed and resolved

This pattern is essential for rate limiting API calls, managing database connections, and controlling resource usage in production applications.

Input & Output

example_1.js — Basic Pool Limit

$ Input: functions = [f1, f2, f3, f4, f5], n = 2 where f1 takes 300ms, f2 takes 400ms, f3 takes 200ms, etc.

› Output: All functions execute with max 2 concurrent at any time Execution order: f1,f2 start → f3 starts when f1 ends → f4 starts when f3 ends → f5 starts when f2 ends

💡 Note: With n=2, we maintain exactly 2 concurrent promises. As soon as one completes, the next function in the queue starts immediately, ensuring optimal resource utilization.

example_2.js — Pool Larger Than Functions

$ Input: functions = [f1, f2], n = 5

› Output: Both functions execute immediately since n > functions.length

💡 Note: When the pool limit exceeds the number of functions, all functions can run concurrently. The pool limit acts as an upper bound.

example_3.js — Single Execution Pool

$ Input: functions = [f1, f2, f3, f4], n = 1

› Output: Functions execute sequentially: f1 → f2 → f3 → f4

💡 Note: With n=1, functions execute in strict sequential order. This is useful for scenarios requiring serialized execution while maintaining the promise-based interface.

Constraints

1 ≤ functions.length ≤ 10⁴
1 ≤ n ≤ 10³
All functions return promises that never reject
Functions must be executed in the given order
The pool limit n represents maximum concurrent promises

Visualization

Tap to expand

Understanding the Visualization

Initialize

Start first n functions up to pool limit

Monitor

Wait for any promise to complete using Promise.race()

Replace

Immediately start next function when slot becomes available

Complete

Continue until all functions are executed and resolved

Key Takeaway

🎯 Key Insight: The promise pool pattern achieves optimal resource utilization by maintaining a constant number of active promises, replacing completed ones immediately to maximize throughput while respecting system constraints.

Asked in

f Meta 45 G Google 38 N Netflix 32 a Amazon 28 ⊞ Microsoft 25

The optimal solution uses a rolling window approach to maintain exactly n concurrent promises. Key insight: as soon as any promise completes, immediately start the next function to maximize efficiency while respecting the pool limit. This pattern is essential for rate limiting and resource management in production applications.

Common Approaches

Approach	Time	Space	Notes
✓ Promise Pool with Active Set (Optimal)	O(n)	O(k)	Maintain a set of active promises, replacing completed ones immediately
Execute All Simultaneously	O(1)	O(n)	Start all functions at once without any concurrency control

Promise Pool with Active Set (Optimal) — Algorithm Steps

Start initial batch of n functions
Store active promises in a set with their indices
Use Promise.race() to wait for any promise to complete
Replace completed promise with next function immediately
Continue until all functions are executed and completed

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial Batch

Start first n functions (n=2: func1, func2)

First Completion

func1 completes, immediately start func3

Continue Rolling

func2 completes, start func4, and so on

Final Resolution

Last functions complete, promise resolves

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <semaphore.h>

// C implementation using POSIX threads and semaphores
typedef struct {
    void (*func)(void*);
    void* arg;
    sem_t* semaphore;
    int* completed_count;
    int total_functions;
    pthread_mutex_t* mutex;
} task_data_t;

void* execute_task(void* arg) {
    task_data_t* data = (task_data_t*)arg;
    
    // Acquire semaphore
    sem_wait(data->semaphore);
    
    // Execute function
    data->func(data->arg);
    
    // Release semaphore
    sem_post(data->semaphore);
    
    // Update completion count
    pthread_mutex_lock(data->mutex);
    (*data->completed_count)++;
    pthread_mutex_unlock(data->mutex);
    
    return NULL;
}

int promise_pool(task_data_t* tasks, int num_tasks, int n) {
    sem_t semaphore;
    sem_init(&semaphore, 0, n);
    
    pthread_t* threads = malloc(num_tasks * sizeof(pthread_t));
    int completed = 0;
    pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
    
    // Set shared data for all tasks
    for (int i = 0; i < num_tasks; i++) {
        tasks[i].semaphore = &semaphore;
        tasks[i].completed_count = &completed;
        tasks[i].total_functions = num_tasks;
        tasks[i].mutex = &mutex;
        
        pthread_create(&threads[i], NULL, execute_task, &tasks[i]);
    }
    
    // Wait for all threads
    for (int i = 0; i < num_tasks; i++) {
        pthread_join(threads[i], NULL);
    }
    
    free(threads);
    sem_destroy(&semaphore);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each function is started exactly once, and we process completions efficiently

✓ Linear Growth

Space Complexity

O(k)

Where k is the pool limit n, we only store n active promises at most

✓ Linear Space

42.8K Views

High Frequency

~25 min Avg. Time

1.5K 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 Active Set (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler