The Node.js Event Loop Explained

“Node.js is single-threaded… then how does it handle so many users?”

The short answer is 👉 The Event Loop

In this article, we’ll understand:

• What the Node.js Event Loop is

• Blocking vs Non-blocking code

• How Node.js handles multiple requests with a single thread

• Async code using callbacks and promises
  All explained in a very simple & beginner-friendly way.

A Simple Analogy: A Chef Handling Multiple Orders 🍳

Imagine a restaurant with one chef.

• Customers place orders

• Some food takes time to cook

• The chef does not wait doing nothing

• While food is cooking, the chef takes other orders

👉 This is exactly how Node.js works

What Is the Node.js Event Loop?

The Event Loop is a system inside Node.js that:

• Keeps track of tasks

• Executes callbacks

• Handles async operations

• Makes Node.js non-blocking

👉 It decides what code should run next

Single Thread ≠ Single Task ❗

Node.js:

• Has one main thread

• But can handle many requests

• Because long tasks are handled asynchronously

That’s the power of the event loop 💪

Blocking Code (Bad ❌)

Blocking code stops everything until it finishes.

Example (Blocking)

const fs = require("fs");

const data = fs.readFileSync("file.txt", "utf-8");
console.log(data);

console.log("This runs last");

👉 Node.js waits for the file
👉 No other request can be processed
👉 Bad for servers ❌

Non-Blocking Code (Good ✅)

Example (Non-Blocking)

const fs = require("fs");

fs.readFile("file.txt", "utf-8", (err, data) => {
  console.log(data);
});

console.log("This runs first");

👉 File reading happens in background
👉 Event loop keeps running
👉 Server stays fast 🚀

Blocking vs Non-Blocking (Easy Comparison)

How Node.js Handles Multiple Requests 🧠

Let’s say:

• User A → file request

• User B → API request

• User C → form submission

Node.js:

1. Accepts all requests

2. Sends slow tasks to background

3. Event loop continues running

4. Responds when tasks are done

👉 No request waits in a long line

Event Loop Phases (Simplified)

The event loop runs in cycles.

Main Phases (Beginner View)

1. Timers → setTimeout, setInterval

2. I/O Callbacks → file & network

3. Poll → waits for new tasks

4. Check → setImmediate

5. Close callbacks

The loop repeats again and again 🔁

Callbacks Explained Simply 🔁

A callback is:

A function that runs after a task finishes

Example

setTimeout(() => {
  console.log("Task completed");
}, 2000);

console.log("Waiting...");

Output

Waiting...
Task completed

👉 Task goes to background
👉 Callback runs later

The Problem with Callbacks 😵

Too many callbacks lead to callback hell.

task1(() => {
  task2(() => {
    task3(() => {
      console.log("Done");
    });
  });
});

❌ Hard to read
❌ Hard to maintain

Promises: A Better Way 🤝

Promises make async code cleaner.

Example

fetchData()
  .then(data => processData(data))
  .then(result => console.log(result))
  .catch(error => console.log(error));

Promise States

Async / Await (Best & Cleanest ✨)

async function getUser() {
  try {
    const user = await fetchUser();
    console.log(user);
  } catch (err) {
    console.log(err);
  }
}

👉 Looks synchronous
👉 Works asynchronously
👉 Uses event loop internally

Blocking vs Non-Blocking Flow Diagram

Blocking Flow

Task A → wait
Task B → wait
Task C

Non-Blocking Flow

Task A → background
Task B → run
Task C → run
Callback when ready

Why the Event Loop Is So Important?

Because it makes Node.js:

• Fast

• Scalable

• Memory-efficient

• Perfect for APIs, chat apps, streaming