Node.js: Async: Event Loop

Last updated: 2026-08-26

1. Story: A Service Blocked by 200 ms

Bob’s API service typically responds in just 5 ms, but during peak hours, response times skyrocketed to 2,000 ms. Users kept complaining, and at first, he thought the database was slow, but adding indexes didn’t help. Later, using console.time to troubleshoot step by step, he discovered that sorting a large synchronous JSON array was taking 200 ms—this 200-ms operation was blocking the event loop, causing all queued requests to wait for it to finish. After understanding how the event loop works, Bob used setImmediate to break the sorting into smaller chunks and execute them in turn, reducing response times during peak hours to 50 ms.

You'll learn:

• Responsibilities and Flow of the 6 Phases of the Event Loop
• Priority of the microtask queue (process.nextTick / Promise.then)
• Scheduling of macro task queues (setTimeout / setImmediate / I/O)
• setTimeout vs setImmediate vs process.nextTick execution order
• Why setImmediate Takes Precedence Over setTimeout in an I/O Context
• The Risks of Blocking the Event Loop and Strategies for Splitting It

2. The 6 Stages of the Event Loop

The Node.js event loop is driven by libuv and proceeds through six phases in sequence. Each loop cycle begins with "timers" and ends with "close callbacks," then returns to "timers" to start the next cycle.

flowchart TD
    A["timers<br/>setTimeout / setInterval"] --> B["pending callbacks<br/>System-Level Callbacks"]
    B --> C["idle, prepare<br/>For internal use only"]
    C --> D["poll<br/>I/O callbacks / new I/O polling"]
    D --> E["check<br/>setImmediate"]
    E --> F["close callbacks<br/>socket.on('close')"]
    F --> A

flowchart TD
    A["timers<br/>setTimeout / setInterval"] --> B["pending callbacks<br/>System-Level Callbacks"]
    B --> C["idle, prepare<br/>For internal use only"]
    C --> D["poll<br/>I/O callbacks / new I/O polling"]
    D --> E["check<br/>setImmediate"]
    E --> F["close callbacks<br/>socket.on('close')"]
    F --> A

3. Microtasks and Macrotasks

(1) (3.1) Microtask Queue

Microtasks are executed in their entirety after the current phase ends and before the next phase begins. The microtask queue has two priority levels:

▶ Example: nextTick takes precedence over Promise.then

process.nextTick(() => {
  console.log('nextTick 1');
});

Promise.resolve().then(() => {
  console.log('promise.then 1');
});

process.nextTick(() => {
  console.log('nextTick 2');
});

Promise.resolve().then(() => {
  console.log('promise.then 2');
});

nextTick 1
nextTick 2
promise.then 1
promise.then 2

(2) (3.2) Macrotask Queue

Macrotasks are scheduled by each phase of the event loop, with each phase executing its corresponding macrotasks.

4. setTimeout vs setImmediate vs process.nextTick

▶ Example: The execution order of outer contexts is undefined

setTimeout(() => {
  console.log('setTimeout');
}, 0);

setImmediate(() => {
  console.log('setImmediate');
});

In a non-I/O context, the execution order of setTimeout and setImmediate is undefined—it depends on the system's process scheduling, and either one may execute first.

▶ Example: In an I/O context, setImmediate is always executed first

const fs = require('fs');

fs.readFile(__filename, () => {
  setTimeout(() => {
    console.log('setTimeout');
  }, 0);

  setImmediate(() => {
    console.log('setImmediate');
  });
});

setImmediate
setTimeout

I/O callbacks are executed during the poll phase; once they are complete, the process moves to the check phase (setImmediate), and only then proceeds to the next round of the timers phase (setTimeout).

▶ Example: process.nextTick always comes first

setTimeout(() => {
  console.log('setTimeout');
}, 0);

setImmediate(() => {
  console.log('setImmediate');
});

process.nextTick(() => {
  console.log('nextTick');
});

nextTick
setTimeout   (or setImmediate, depends on scheduling)
setImmediate

5. Comparison of Microtasks vs. Macrotasks

▶ Example: Micro-tasks interspersed among macro-tasks

setTimeout(() => {
  console.log('timeout 1');
  Promise.resolve().then(() => {
    console.log('promise between 1 and 2');
  });
}, 0);

setTimeout(() => {
  console.log('timeout 2');
}, 0);

timeout 1
promise between 1 and 2
timeout 2

After each macro-task is completed, the micro-task queue is cleared before the next macro-task is executed.

6. The Dangers of Blocking the Event Loop and How to Avoid Them

▶ Example: Blocking the Event Loop

const http = require('http');

const server = http.createServer((req, res) => {
  const start = Date.now();
  while (Date.now() - start < 200) {}
  res.end('done');
});

server.listen(3000, () => {
  console.log('Server running on port 3000');
});

Each request blocks the event loop for 200 ms, during which time no other requests can be processed.

▶ Example: Breaking Down Long-Running Tasks with setImmediate

function chunkedSort(arr, compareFn, callback) {
  const CHUNK = 1000;
  let offset = 0;

  function sortChunk() {
    const end = Math.min(offset + CHUNK, arr.length);
    for (let i = offset; i < end; i++) {
      for (let j = i + 1; j < end; j++) {
        if (compareFn(arr[i], arr[j]) > 0) {
          [arr[i], arr[j]] = [arr[j], arr[i]];
        }
      }
    }
    offset = end;
    if (offset < arr.length) {
      setImmediate(sortChunk);
    } else {
      callback(arr);
    }
  }

  setImmediate(sortChunk);
}

chunkedSort(
  [5, 3, 8, 1, 9, 2, 7, 4, 6],
  (a, b) => a - b,
  (result) => {
    console.log('Sorted:', result);
  }
);

7. Comprehensive Example: Script to Verify the Execution Order of the Event Loop

The following script verifies the complete execution order of setTimeout → process.nextTick → setImmediate → Promise.then → I/O callback.

const fs = require('fs');

console.log('--- Script start ---');

setTimeout(() => {
  console.log('1. setTimeout (macrotask - timers)');
}, 0);

setImmediate(() => {
  console.log('2. setImmediate (macrotask - check)');
});

process.nextTick(() => {
  console.log('3. process.nextTick (microtask - highest)');
});

Promise.resolve().then(() => {
  console.log('4. Promise.then (microtask)');
});

fs.readFile(__filename, () => {
  console.log('5. I/O callback (poll phase)');

  setTimeout(() => {
    console.log('6.   inner setTimeout');
  }, 0);

  setImmediate(() => {
    console.log('7.   inner setImmediate');
  });

  process.nextTick(() => {
    console.log('8.   inner nextTick');
  });

  Promise.resolve().then(() => {
    console.log('9.   inner Promise.then');
  });
});

console.log('--- Script end ---');

--- Script start ---
--- Script end ---
3. process.nextTick (microtask - highest)
4. Promise.then (microtask)
1. setTimeout (macrotask - timers)
2. setImmediate (macrotask - check)
5. I/O callback (poll phase)
8.   inner nextTick
9.   inner Promise.then
7.   inner setImmediate
6.   inner setTimeout

Analysis of Execution Order:

1. The synchronous code runs first, outputting "Script start" and "Script end"
2. Clear microtasks after the current phase ends: nextTick → Promise.then
3. Enter the "timers" phase: setTimeout
4. Enter the check phase: setImmediate
5. Execute the callback during the poll phase after I/O is complete
6. Clear the microtask after the I/O callback completes: inner nextTick → inner Promise.then
7. When the poll ends, enter the check: inner setImmediate
8. Next round of timers: inner setTimeout

❓ FAQ

📖 Summary

• Story: The Core Concepts and Usage of a Service Blocked by 200 ms
• Key Concepts and Usage of the 6 Phases of the Event Loop
• Core Concepts and Usage of Micro-Tasks and Macro-Tasks
• Key Concepts and Usage of setTimeout, setImmediate, and process.nextTick
• Key Concepts and Usage of Micro-Tasks vs. Macro-Tasks
• The Risks of Blocking the Event Loop, Key Concepts for Avoiding It, and How to Do It
• Comprehensive Example: Verifying the Execution Order of the Event Loop—Core Concepts and Usage of Scripts

📝 Exercises

1. Complete all the code examples in this lesson and make sure each one runs correctly.
2. Modify the comprehensive example and add your own extensions
3. Review the official documentation, identify 1–2 APIs not covered in this lesson, and write test code for them.
4. Reflection: How would you apply what you’ve learned in this lesson to a real-world project?
5. Try to combine what you’ve learned in this lesson with material from previous lessons to build a small project.

Web-Tutorial Tech Team

A team of developers maintaining programming tutorials. Each tutorial is written and reviewed by developers with expertise in that field. We work to keep our content accurate and reliable — if you spot an issue, please let us know.

About Us