Node.js Architecture and Event Loop

Node.js is a cross-platform, open-source JavaScript runtime environment built on Chrome V8 engine. Unlike traditional multi-threaded web servers, Node.js operates on a single-threaded event-driven model, allowing it to handle concurrent operations with high efficiency.

1. The Core Components of Node.js

The internal architecture of Node.js consists of three primary layers:

• Chrome V8 Engine: Google high-performance JavaScript engine written in C++. It compiles JavaScript code directly into native machine code instead of interpreting it in real-time.
• Libuv: A multi-platform support library written in C++ with a focus on asynchronous I/O. It provides the event loop, thread pool, and non-blocking network/file system behaviors.
• C++ Bindings: The bridge layer that allows JavaScript code to communicate with lower-level C++ libraries, exposing OS capabilities to JS.

2. Under the Hood: Libuv Thread Pool

Although JavaScript execution in Node.js runs on a single thread (the main thread), certain operations are offloaded to Libuv helper threads because they are blocking by nature.

Libuv manages a thread pool (default size is 4 threads) to handle:

• File system operations (fs)
• Cryptographic functions (crypto)
• Compression operations (zlib)
• DNS lookup resolution

You can configure the thread pool size using the following environment variable before starting your Node.js application:

# Increase Libuv thread pool size to 8 threads
export UV_THREADPOOL_SIZE=8

3. The Event Loop Stages

The Event Loop is the heart of Node.js. It continually coordinates asynchronous tasks. The loop consists of six main phases, executing in a specific cyclic order:

1. Timers: Executes callbacks scheduled by setTimeout and setInterval.
2. Pending Callbacks: Executes I/O callbacks deferred to the next loop iteration (e.g., TCP socket errors).
3. Idle, Prepare: Used only internally by Node.js.
4. Poll: Retrieves new I/O events; executes I/O-related callbacks. Node.js may block here if no timers are scheduled.
5. Check: Executes callbacks scheduled by setImmediate.
6. Close Callbacks: Executes close event callbacks (e.g., socket.on("close", ...)).

4. Microtask Queue: process.nextTick and Promises

In addition to the main phases, Node.js maintains two microtask queues that execute immediately after the current operation finishes, before the event loop moves to the next phase:

1. nextTick Queue: Callbacks scheduled by process.nextTick.
2. Promise Queue: Callbacks resolved by Promises (microtasks).

The nextTick queue has a higher priority than the Promise queue.

Here is a practical code example illustrating execution order:

// A demonstration of execution order in the Node.js event loop and microtask queues
console.log("Start");

setTimeout(() => {
  console.log("setTimeout (Timers Phase)");
}, 0);

setImmediate(() => {
  console.log("setImmediate (Check Phase)");
});

process.nextTick(() => {
  console.log("process.nextTick (Microtask 1)");
});

Promise.resolve().then(() => {
  console.log("Promise.then (Microtask 2)");
});

console.log("End");

Output:

Start
End
process.nextTick (Microtask 1)
Promise.then (Microtask 2)
setTimeout (Timers Phase)
setImmediate (Check Phase)

5. Non-Blocking I/O Best Practices

To keep Node.js applications fast and responsive, follow these rules:

• Never block the Event Loop: Avoid running CPU-intensive operations (such as large loops, heavy crypto, or synchronous file reads) on the main thread.
• Use Asynchronous APIs: Always prefer asynchronous methods over synchronous ones. For example, use fs.promises.readFile instead of fs.readFileSync.
• Offload Heavy Computation: Use worker threads (worker_threads) or child processes if you need to perform CPU-intensive tasks.