What is the event loop in Node.js and how does it work?

Question

Accepted Answer

The **event loop** is the mechanism that lets single-threaded Node.js perform **non-blocking I/O**. It continuously processes a queue of callbacks: while your JavaScript runs on one thread, I/O operations are offloaded, and their callbacks are run by the loop when they complete.

## The phases of the loop

Each iteration ("tick") moves through ordered phases, each with its own callback queue:

```text
   ┌───────────────────────────┐
┌─>│   timers (setTimeout)     │  ← expired timer callbacks
│  ├───────────────────────────┤
│  │   pending I/O callbacks   │
│  ├───────────────────────────┤
│  │   poll (I/O events)       │  ← retrieve new I/O; execute their callbacks
│  ├───────────────────────────┤
│  │   check (setImmediate)    │
│  ├───────────────────────────┤
└──│   close callbacks         │
   └───────────────────────────┘
```

## Microtasks run between phases (high priority)

```js
console.log("1");                          // sync
setTimeout(() => console.log("2"), 0);     // timers phase (macrotask)
setImmediate(() => console.log("3"));      // check phase
Promise.resolve().then(() => console.log("4")); // microtask
process.nextTick(() => console.log("5"));  // nextTick — highest priority
console.log("6");
// Output: 1, 6, 5, 4, 2/3 (timer vs immediate order can vary)
```

After each phase (and after sync code), Node drains **microtasks**: `process.nextTick` callbacks first, then Promise callbacks — *before* moving on. This is why a resolved Promise runs before a `setTimeout(…, 0)`.

## Why it enables concurrency without threads

```text
A DB query or file read is handed to the OS/thread pool → Node keeps running
other code → when the result is ready, its callback is queued → the loop runs it.
One thread, thousands of in-flight operations.
```

## The cardinal rule: don't block the loop

```js
// ❌ a long synchronous loop freezes EVERYTHING — no other callback can run
while (Date.now() - start < 5000) {}
```

Blocking the single thread halts all request handling. Offload CPU-heavy work to worker threads.

## Why it matters

The event loop is the heart of Node's performance model — understanding its phases and the microtask priority explains async ordering, why Node handles huge concurrency on one thread, and the critical rule never to block it.

It's foundational to writing correct, performant Node code and to debugging surprising async execution order.