Sequential vs parallel async execution in Node.js - Practice Questions

Challenge - 5 Problems

🧠 Conceptual

intermediate

Understanding async function execution order

Consider two async functions called one after another without awaiting the first. What is the behavior of their execution?

Node.js

async function first() {
  console.log('First start');
  await new Promise(resolve => setTimeout(resolve, 100));
  console.log('First end');
}

async function second() {
  console.log('Second start');
  await new Promise(resolve => setTimeout(resolve, 50));
  console.log('Second end');
}

first();
second();

A Logs 'First start', then 'Second start', then 'Second end', then 'First end' in that order.

B Logs 'First start', 'First end', 'Second start', 'Second end' in that order.

C Logs 'Second start', 'Second end', 'First start', 'First end' in that order.

D Logs 'First start', 'Second start', 'First end', 'Second end' in that order.

💡 Hint

Think about how async functions start immediately but pause at await.

Calling async functions without awaiting starts them immediately. Both 'First start' and 'Second start' log quickly. Then the shorter timeout in second() resolves first, so 'Second end' logs before 'First end'.

❓ component_behavior

intermediate

Effect of awaiting promises sequentially vs in parallel

What is the total approximate time taken by the following two code snippets, assuming each asyncTask takes 100ms to complete?

Node.js

async function asyncTask() {
  return new Promise(resolve => setTimeout(resolve, 100));
}

// Snippet 1
async function sequential() {
  await asyncTask();
  await asyncTask();
}

// Snippet 2
async function parallel() {
  await Promise.all([asyncTask(), asyncTask()]);
}

A Both snippets take about 200ms to complete.

B Sequential takes about 100ms; parallel takes about 200ms.

C Both snippets take about 100ms to complete.

D Sequential takes about 200ms; parallel takes about 100ms.

💡 Hint

Consider if tasks run one after the other or at the same time.

Sequential awaits each task one after the other, so total time adds up. Parallel runs both tasks simultaneously, so total time is about the longest single task.

🔧 Debug

advanced

Identify the error in parallel async execution

What error will this code produce when run in Node.js 20+?

Node.js

async function fetchData(id) {
  return new Promise(resolve => setTimeout(() => resolve(id), 100));
}

async function run() {
  const results = await Promise.all(fetchData(1), fetchData(2));
  console.log(results);
}

run();

A SyntaxError due to missing brackets in Promise.all.

B [1, 2] logged after 100ms delay.

C TypeError: Promise.all accepts an iterable but received multiple arguments.

D ReferenceError: fetchData is not defined.

💡 Hint

Check how Promise.all expects its arguments.

Promise.all expects a single iterable (like an array) of promises. Passing multiple arguments causes a TypeError.

❓ state_output

advanced

State changes in sequential vs parallel async updates

Given this code, what will be the final value of count after running sequential() and parallel() respectively?

Node.js

let count = 0;

function delayAdd(value) {
  return new Promise(resolve => setTimeout(() => {
    count += value;
    resolve(count);
  }, 100));
}

async function sequential() {
  await delayAdd(1);
  await delayAdd(2);
}

async function parallel() {
  await Promise.all([delayAdd(1), delayAdd(2)]);
}

A After sequential: count = 3; after parallel: count = 2

B After sequential: count = 3; after parallel: count = 3

C After sequential: count = 3; after parallel: count = 1

D After sequential: count = 1; after parallel: count = 3

💡 Hint

Consider how count is updated in both cases.

Both sequential and parallel add 1 and 2 to count. Sequentially, count updates stepwise. Parallel updates happen concurrently but both increments apply, so total is 3 in both cases.

📝 Syntax

expert

Correct syntax for parallel async execution with error handling

Which option correctly runs two async tasks in parallel and catches errors properly?

Node.js

async function task1() {
  throw new Error('fail1');
}

async function task2() {
  return 'success2';
}

async function run() {
  // Fill in the blank
}

A

try {
  const results = await Promise.all([task1(), task2()]);
  console.log(results);
} catch (e) {
  console.error('Error:', e.message);
}

B

const results = await Promise.allSettled([task1(), task2()]);
console.log(results);

C

try {
  const results = await Promise.all(task1(), task2());
  console.log(results);
} catch (e) {
  console.error('Error:', e.message);
}

D

const results = await Promise.all([task1(), task2()]).catch(e => console.error(e));
console.log(results);

💡 Hint

Check how Promise.all and try/catch work together.

Option A correctly uses Promise.all with an array and wraps it in try/catch to handle errors. Option A uses allSettled which doesn't throw but returns statuses. Option A passes multiple arguments to Promise.all causing error. Option A logs results after catch but results is undefined if error occurs.