Node.js Event Loop: A Beginner's Guide

The Heart of Node.js#

Node.js is famous for being "Single-Threaded" yet capable of handling thousands of concurrent connections. This seems like a contradiction.

• Single-threaded means doing one thing at a time.
• Servers need to do many things at a time (serve User A, User B, User C...).

If it only has one thread, shouldn't it freeze every time one user requests a large file?

The secret sauce is the Event Loop.

The Reactor Pattern#

Node.js uses an architecture called the Reactor Pattern.

1. The Event Demultiplexer (Notification System): Node sends a request to the OS (e.g., "Read this file") and provides a handler (callback).
2. Non-Blocking I/O: The OS (Kernel) does the heavy lifting in the background using its own threads. Node.js continues to the next line of code immediately.
3. The Event Queue: When the OS finishes the task, it pushes the event (and the data) into a queue.
4. The Event Loop: This is an infinite loop that constantly checks the queue. If there's an event waiting, and the call stack is empty, it executes the callback.

Analogy: The Waiter in a Busy Restaurant#

Imagine a restaurant with one waiter (The Single Thread) and many chefs (The OS / Worker Pool).

Scenario A: The Blocking Model (Apache / Old PHP)

The waiter takes an order from Table 1. He walks to the kitchen. He stands there and waits for 20 minutes while the chef cooks. He serves Table 1. Only then does he go to Table 2.

Result: Table 2 waits forever just because Table 1 ordered a steak. This is inefficient.

Scenario B: The Non-Blocking Event Loop (Node.js)

The waiter takes an order from Table 1. He sticks the ticket on the kitchen wall. He immediately goes to Table 2 and takes their order. He takes Table 3's order. Suddenly, the Chef rings a bell ("Order Up!"). The waiter picks up the food and serves Table 1.

Result: One waiter can serve 100 tables efficiently, as long as he is basically just taking orders and delivering food (I/O) and not cooking it himself (CPU).

The Golden Rule: Don't Block the Loop#

Because there is only one waiter, he must never get stuck doing a heavy task himself.

Blocking Code (Bad):

// A loop that takes 5 seconds to finish
const end = Date.now() + 5000;
while (Date.now() < end) {
    // Math...
}

If you run this, no other user can connect to your server for 5 seconds. The waiter is stuck solving a math problem at Table 4.

Non-Blocking Code (Good):

// Schedule it for later
setTimeout(() => {
    console.log("5 seconds passed");
}, 5000);

Node.js sees setTimeout, tells the timer mechanism "Wake me up in 5s", and immediately moves on.

Phases of the Loop#

The Event Loop isn't just one queue. It has multiple phases:

1. Timers: Checks for setTimeout and setInterval.
2. Pending Callbacks: System errors.
3. Poll: Retrieves new I/O events (reading files, network requests).
4. Check: setImmediate callbacks.
5. Close: Closing connections (socket.on('close')).

Summary#

Node.js is fast because it delegates work. It uses the Event Loop to orchestrate tasks without blocking the main thread. This makes it perfect for I/O-heavy apps like Chat servers, APIs, and Streaming. It makes it terrible for CPU-heavy apps (like video encoding), unless you use Worker Threads.

Visualize the loop in our Runner