Sequential vs parallel execution in Javascript - Practice Questions

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of sequential async calls

What will be the output of this JavaScript code that runs two async functions sequentially?

Javascript

async function task(name, delay) {
  return new Promise(resolve => {
    setTimeout(() => {
      console.log(name);
      resolve(name);
    }, delay);
  });
}

async function run() {
  await task('First', 100);
  await task('Second', 50);
  console.log('Done');
}

run();

A First\nDone\nSecond

B Second\nFirst\nDone

C Done\nFirst\nSecond

D First\nSecond\nDone

💡 Hint

Remember that await pauses the function until the promise resolves.

The first task waits 100ms and prints 'First'. Only after it finishes, the second task starts and prints 'Second' after 50ms. Finally, 'Done' is printed.

❓ Predict Output

intermediate

Output of parallel async calls with Promise.all

What will be the output of this JavaScript code that runs two async functions in parallel?

Javascript

async function task(name, delay) {
  return new Promise(resolve => {
    setTimeout(() => {
      console.log(name);
      resolve(name);
    }, delay);
  });
}

async function run() {
  await Promise.all([task('First', 100), task('Second', 50)]);
  console.log('Done');
}

run();

A Second\nFirst\nDone

B First\nSecond\nDone

C Done\nFirst\nSecond

D First\nDone\nSecond

💡 Hint

Promise.all runs promises in parallel and waits for all to finish.

Both tasks start at the same time. 'Second' finishes first after 50ms, then 'First' after 100ms. After both finish, 'Done' is printed.

❓ Predict Output

advanced

Output of mixed sequential and parallel async calls

What will be the output of this code that mixes sequential and parallel async calls?

Javascript

async function task(name, delay) {
  return new Promise(resolve => {
    setTimeout(() => {
      console.log(name);
      resolve(name);
    }, delay);
  });
}

async function run() {
  await task('First', 100);
  await Promise.all([task('Second', 50), task('Third', 70)]);
  console.log('Done');
}

run();

A Second\nThird\nFirst\nDone

B First\nSecond\nThird\nDone

C First\nDone\nSecond\nThird

D First\nThird\nSecond\nDone

💡 Hint

The first task runs alone, then the next two run together.

The first task prints 'First' after 100ms. Then 'Second' and 'Third' run in parallel; 'Second' prints after 50ms, 'Third' after 70ms. Finally, 'Done' is printed.

❓ Predict Output

advanced

Output order with Promise.race

What will be the output of this code using Promise.race with two async tasks?

Javascript

async function task(name, delay) {
  return new Promise(resolve => {
    setTimeout(() => {
      console.log(name);
      resolve(name);
    }, delay);
  });
}

async function run() {
  await Promise.race([task('First', 100), task('Second', 50)]);
  console.log('Done');
}

run();

A Second\nDone\nFirst

B First\nDone

C Done\nFirst\nSecond

D First\nSecond\nDone

💡 Hint

Promise.race resolves as soon as the first promise resolves.

'Second' finishes first after 50ms and prints 'Second'. Promise.race resolves then, so 'Done' is printed next. 'First' prints later but after 'Done'.

🧠 Conceptual

expert

Understanding event loop and parallelism in JavaScript

Which statement best describes how JavaScript handles parallel execution and the event loop?

A JavaScript runs multiple threads in parallel to execute code simultaneously.

B JavaScript executes all code synchronously and blocks until each task finishes.

C JavaScript uses a single thread and runs asynchronous tasks via the event loop to simulate parallelism.

D JavaScript creates a new thread for each async function automatically.

💡 Hint

Think about how JavaScript handles async tasks without real threads.

JavaScript runs on a single thread but uses the event loop to handle asynchronous tasks, allowing non-blocking behavior and simulating parallelism.