Skip to main content

Node.js Architecture

Node.js is a powerful runtime environment designed to handle asynchronous operations efficiently using JavaScript. This document provides an overview of its key architectural components.

1. Event-Driven Architecture​

Event Loop​

The core of Node.js's non-blocking model is the event loop. It allows Node.js to perform operations asynchronously without blocking the execution thread.

  • Phases: The event loop consists of several phases:

    1. Timers: Executes callbacks scheduled by setTimeout and setInterval.
    2. IO Callbacks: Executes callbacks for almost all operations, with some exceptions.
    3. Idle, Prepare: Internal maintenance and preparation.
    4. Poll: Retrieves new I/O events and executes their callbacks.
    5. Check: Executes callbacks scheduled by setImmediate.
    6. Close Callbacks: Executes close events, such as socket.on('close').

  • Blocking vs Non-Blocking: The event loop is non-blocking, but synchronous code can block it. Asynchronous operations are handled without blocking the event loop.

Events and Callbacks​

  • Event Emitter: Node.js uses the EventEmitter class to handle events. Objects that emit events are instances of this class.
  • Callbacks: Functions passed as arguments to asynchronous operations. They are executed when the operation completes.

2. Single-Threaded Model​

Thread Management​

  • JavaScript Execution: Node.js operates on a single-threaded model for JavaScript execution, simplifying concurrency management.
  • Worker Threads: For CPU-intensive tasks, Node.js can use the worker_threads module to offload work to additional threads, avoiding event loop blocking.

3. Non-Blocking I/O​

Asynchronous I/O​

  • Non-Blocking Calls: Functions like fs.readFile are non-blocking, allowing the event loop to handle other tasks while waiting for I/O operations to complete.
  • Event Loop Queue: Asynchronous operations are queued in the event loop, with callbacks executed once their events are triggered.

Libuv Library​

  • Thread Pool: libuv provides a thread pool (default 4 threads) for background I/O operations.
  • Handles and Requests: libuv manages handles (e.g., timers, sockets) and requests (e.g., I/O operations).

4. V8 JavaScript Engine​

JIT Compilation​

  • Just-In-Time Compilation: V8 compiles JavaScript to native machine code at runtime, enhancing performance.
  • Garbage Collection: V8 automatically manages memory allocation and garbage collection, though developers should be aware of memory usage.

5. Modules​

CommonJS Modules​

  • Module.exports: Defines what a module exports, making it available to other modules.
  • Require Function: Loads and caches modules. Modules are cached after the first load to improve performance.

ES Modules​

  • Import/Export: Supports import and export statements for modular code.
  • Dynamic Import: Allows for runtime loading of modules using import().

6. Native Addons​

Addons​

  • N-API: Provides a stable ABI for building native addons. It enables interaction with low-level system features or extending Node.js functionality.
  • Node-ffi and Nan: Tools for interfacing with native libraries and creating addons.

7. Process Model​

Cluster Module​

  • Process Forking: The cluster module enables creation of child processes (workers) that share server ports, facilitating load balancing across multiple CPU cores.
  • Master and Workers: One master process manages multiple worker processes, distributing tasks.

Process Management​

  • PM2: A popular process manager providing features like monitoring, logging, and clustering for Node.js applications.

8. Networking and HTTP​

HTTP Server​

  • HTTP Module: The http module enables the creation of HTTP servers and handling of requests and responses.
  • Express: A higher-level framework built on top of the http module, simplifying web application development.

Socket.io​

  • Real-Time Communication: A library for real-time, bidirectional communication using WebSockets and other protocols.

9. Error Handling​

Error-First Callbacks​

  • Error Handling: Callbacks usually follow the pattern (err, result), where the first argument is an error object, and the second is the result of the operation.

Promises and Async/Await​

  • Promises: Represent the eventual result of asynchronous operations, with .then and .catch methods for handling success and failure.
  • Async/Await: Provides a more readable syntax for handling asynchronous code. async functions return promises, and await pauses execution until the promise resolves.