Understanding the Node.js Event Loop

Mar 8, 2025

Ever heard someone say, "Node.js is single-threaded but can handle thousands of concurrent requests" and wondered, HOW? 🤯

The answer lies in the Event Loop—the heart of Node.js' asynchronous behavior. Today, we’re breaking it down in a simple, no-BS way.

🚀 What is the Event Loop?

The Event Loop is what makes asynchronous, non-blocking I/O possible in JavaScript.

Imagine you're at a restaurant:

  • The waiter (Event Loop) takes multiple orders (incoming requests).
  • Instead of waiting for one dish to cook (blocking), they move on to the next customer.
  • When a dish is ready, they serve it (callback execution).

Node.js works the same way—handling multiple tasks without getting stuck.

🔥 The 6 Phases of the Event Loop

The Event Loop is made up of six phases, running in cycles:

1️⃣ Timers → Runs setTimeout() and setInterval() callbacks.
2️⃣ Pending Callbacks → Executes deferred I/O callbacks.
3️⃣ Idle, Prepare → Used internally by Node.js (not important for devs).
4️⃣ Poll → Processes new I/O events (e.g., reading files, network requests).
5️⃣ Check → Executes setImmediate() callbacks.
6️⃣ Close Callbacks → Runs cleanup operations (e.g., socket.on('close')).

Each cycle runs all pending tasks before moving on to the next phase.

🛠 Hands-on Example: Timers vs. Immediate

Let’s compare setTimeout() and setImmediate():

setTimeout(() => console.log("⏳ Timeout callback"), 0);
setImmediate(() => console.log("🚀 Immediate callback"));
console.log("🎬 Script start");

🧪 What happens?

🎬 Script start
🚀 Immediate callback
⏳ Timeout callback

🔍 Why?

  • setImmediate() runs after the poll phase, making it execute sooner.
  • setTimeout(..., 0) waits until the next timer phase.

⚡ Async I/O in the Event Loop

I/O operations like reading a file use the Poll Phase.

import { readFile } from "fs";

console.log("🎬 Start reading file...");

readFile("example.txt", "utf8", (err, data) => {
  console.log("📖 File read completed!");
});

console.log("🚀 Other tasks running...");

🧪 What happens?

🎬 Start reading file...
🚀 Other tasks running...
📖 File read completed!

🔍 Why?

  • readFile() is asynchronous, so Node.js doesn’t block execution.
  • The Event Loop continues with other tasks until the file is ready.

🎭 Microtasks: process.nextTick() vs. Promises

Node.js has a Microtask Queue, which runs before the next Event Loop phase.

setTimeout(() => console.log("⏳ setTimeout"), 0);
setImmediate(() => console.log("🚀 setImmediate"));
process.nextTick(() => console.log("🐇 nextTick"));
Promise.resolve().then(() => console.log("✨ Promise"));
console.log("🎬 Script start");

🧪 What happens?

🎬 Script start
🐇 nextTick
✨ Promise
⏳ setTimeout
🚀 setImmediate

🔍 Why?

  • process.nextTick() and Promises run before any timers or immediate tasks.
  • setTimeout() and setImmediate() wait for their respective phases.

🎯 Why Does This Matter?

Understanding the Event Loop helps you:

  1. Write non-blocking code 🚀 → Avoid blocking the main thread with CPU-heavy tasks.
  2. Optimize performance 🔥 → Know when to use setImmediate(), setTimeout(), and process.nextTick().
  3. Debug async issues 🕵️‍♂️ → Fix unexpected delays in execution.
  4. Handle large-scale applications 📡 → Scale up your Node.js backend efficiently.
  5. Avoid callback hell 😵‍💫 → Know when to use async/await vs. callbacks.

TL;DR: The Event Loop is why Node.js can handle thousands of requests without breaking a sweat. Mastering it makes you a better developer! 🚀

🔗 Final Thoughts

  • The Event Loop is what makes Node.js asynchronous.
  • Timers (setTimeout) and Immediate (setImmediate) behave differently.
  • I/O tasks go through the Poll Phase.
  • Microtasks (nextTick & Promises) run before timers.

Understanding this makes you a better Node.js developer! 🚀

Let me know if you have any questions! 😊🔥

diogoaoliveira.com