Node.js Event Loop (Animated)

What is the Node.js Event Loop?

Unlike many other environments where each request might spawn a new thread, Node.js operates primarily on a single main thread. This sounds limiting, but it achieves high concurrency and performance through an **event-driven, non-blocking I/O model**, powered by the **Event Loop**.

Think of the Event Loop as a constantly running process that orchestrates tasks. When Node.js starts, it initializes the loop, processes the input script (which might register async operations), and then enters the loop. The loop's job is to check for pending events (like completed I/O, timers) and execute their associated callback functions.

The key is non-blocking I/O. Instead of waiting for slow operations (like reading a file or making a network request), Node.js delegates these tasks to the operating system or a worker thread pool (managed by the libuv library). When the operation completes, the OS/libuv notifies Node.js by placing the corresponding callback function into a queue. The Event Loop picks up these callbacks from the queue and executes them on the main thread when it gets a chance.

Core Components Visualized

• Call Stack: (Red border) Where synchronous JavaScript function calls are executed (LIFO - Last In, First Out). Blocking code here freezes the loop.
• Node APIs / Background Tasks: (Blue border) Represents where Node.js initiates async operations (timers, I/O) handled by libuv/OS off the main thread. Tasks wait here until complete.
• Microtask Queue: (Orange border) High priority queue for process.nextTick callbacks (executed first within this queue) and resolved Promise callbacks (.then, .catch). Processed immediately after the current script/callback finishes and between event loop phases.
• Callback (Macrotask) Queue: (Teal border) Lower priority queue holding callbacks for completed timers, I/O, setImmediate, etc. Processed during specific Event Loop phases.

The Event Loop Phases (Simplified Cycle)

The loop cycles through phases, processing specific queues in each:

1. Timers: Executes expired setTimeout / setInterval callbacks.
2. I/O Callbacks (Pending): Handles certain system-level callbacks (less common).
3. Poll: Retrieves new I/O events, executes I/O-related callbacks (e.g., file read complete). Blocks briefly if needed.
4. Check: Executes setImmediate callbacks.
5. Close Callbacks: Handles close events (e.g., socket closed).

Crucially, after *each* callback from a macrotask queue (or the initial script), the *entire* Microtask Queue is processed before moving to the next callback or the next phase.