Execute Asynchronous Functions in Parallel

Execute Asynchronous Functions in Parallel - Problem

JavaScript Medium

Imagine you're a concert conductor who needs to coordinate multiple musicians to play their parts simultaneously. In the programming world, you're tasked with executing multiple asynchronous functions in parallel and collecting their results.

Given an array of asynchronous functions, you need to create a new promise that:

✅ Resolves when all functions complete successfully, returning an array of results in the same order as the input functions
❌ Rejects immediately when any function fails, with the reason from the first rejection

🚫 Challenge: You cannot use the built-in Promise.all() function - you must implement this functionality from scratch!

Example: If you have functions that resolve to ["hello", "world", "!"], your promise should resolve to ["hello", "world", "!"] in exactly that order, even if the functions complete in a different sequence.

Input & Output

example_1.js — Basic Success Case

$ Input: functions = [() => Promise.resolve(1), () => Promise.resolve(2), () => Promise.resolve(3)]

› Output: [1, 2, 3]

💡 Note: All three functions resolve successfully. The promise resolves with an array containing all results in the original order, even though the functions might complete at different times.

example_2.js — Different Timing

$ Input: functions = [() => delayResolve('fast', 50), () => delayResolve('slow', 200), () => delayResolve('medium', 100)]

› Output: ['fast', 'slow', 'medium']

💡 Note: Even though 'fast' completes first (50ms), 'medium' second (100ms), and 'slow' last (200ms), the results maintain the original array order. Total execution time is 200ms (not 350ms) due to parallel execution.

example_3.js — Early Rejection

$ Input: functions = [() => delayResolve('success', 100), () => delayReject('error', 50), () => delayResolve('never seen', 200)]

› Output: Promise rejects with 'error'

💡 Note: The second function rejects after 50ms. The entire promise immediately rejects with this error, even though the first function would have succeeded and the third function is still running.

Visualization

Tap to expand

Understanding the Visualization

Conductor Raises Baton

Initialize state: results array, completion counter, rejection flag

All Musicians Start Playing

Execute all async functions simultaneously - true parallelism

Track Each Performance

As each function completes, store result at correct index and increment counter

Handle Mistakes Immediately

If any function fails, immediately stop and report the error

Complete Performance

When all succeed, return ordered results array

Key Takeaway

🎯 Key Insight: Start all promises simultaneously, track completion with a counter, maintain order with indexed storage, and fail fast on first rejection - this achieves optimal O(max(T₁,T₂,...,Tₙ)) time complexity instead of O(T₁+T₂+...+Tₙ).

Time & Space Complexity

Time Complexity

⏱️

O(max(T₁, T₂, ..., Tₙ))

Total time is only as long as the slowest promise since they run in parallel

✓ Linear Growth

Space Complexity

O(n)

Need to store results array and track state for n promises

⚡ Linearithmic Space

Constraints

1 ≤ functions.length ≤ 10³
Each function returns a Promise
Functions accept no arguments
Cannot use built-in Promise.all()
Must maintain original order in results
Must reject immediately on first failure

Asked in

f Meta 45 G Google 38 a Amazon 35 ⊞ Microsoft 28 N Netflix 22

The optimal solution executes all promises simultaneously in parallel, uses a completion counter to track progress, and maintains original order in results. Key insights: start all promises immediately, use index-based result storage, and implement fail-fast behavior for immediate rejection on first error.

Common Approaches

Approach	Time	Space	Notes
✓ Sequential Execution (Await Each)	O(T₁ + T₂ + ... + Tₙ)	O(n)	Execute each async function one after another using await
Promise Counter with State Tracking (Optimal)	O(max(T₁, T₂, ..., Tₙ))	O(n)	Execute all promises simultaneously and track completion with counter and state flags

Sequential Execution (Await Each) — Algorithm Steps

Create an empty results array
Loop through each function in the array
Await each function call sequentially
Store each result in the results array
Return the completed results array

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Function 1

Execute first function and wait for completion

Start Function 2

Only after function 1 completes, start function 2

Start Function 3

Only after function 2 completes, start function 3

Collect Results

Return array with all results in order

Code -

solution.c — C

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

typedef struct {
    char* value;
    int delay_ms;
} async_task_t;

typedef struct {
    char** results;
    int count;
    int error;
} promise_result_t;

// Sequential execution function
promise_result_t* promise_all_sequential(async_task_t* tasks, int count) {
    promise_result_t* result = malloc(sizeof(promise_result_t));
    result->results = malloc(count * sizeof(char*));
    result->count = count;
    result->error = 0;
    
    for (int i = 0; i < count; i++) {
        // Sequential execution - wait for each task
        usleep(tasks[i].delay_ms * 1000); // Convert ms to microseconds
        result->results[i] = tasks[i].value;
    }
    
    return result;
}

int main() {
    async_task_t tasks[] = {
        {"first", 100},
        {"second", 50},
        {"third", 200}
    };
    
    promise_result_t* result = promise_all_sequential(tasks, 3);
    
    printf("Results: ");
    for (int i = 0; i < result->count; i++) {
        printf("%s ", result->results[i]);
    }
    printf("\n");
    
    free(result->results);
    free(result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(T₁ + T₂ + ... + Tₙ)

Total time is the sum of all individual function execution times, as they run sequentially

✓ Linear Growth

Space Complexity

O(n)

Need to store results array of size n

⚡ Linearithmic Space

Constraints

1 ≤ functions.length ≤ 10³
Each function returns a Promise
Functions accept no arguments
Cannot use built-in Promise.all()
Must maintain original order in results
Must reject immediately on first failure

42.4K Views

Very High Frequency

~25 min Avg. Time

1.8K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Sequential Execution (Await Each) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler