How the Single Threaded Non Blocking IO Model Works in NodeJS ?

Node.js has revolutionized the way server-side applications are built by introducing a unique single-threaded, non-blocking I/O model. This model provides significant advantages in terms of performance and scalability, particularly for I/O-bound operations. In this article, we will delve into how this model works and why it is beneficial for modern web applications.

What is the Single-Threaded Non-Blocking I/O Model?

Single-Threaded

In traditional multi-threaded server architectures, each incoming request is handled by a separate thread. This approach can lead to significant overhead due to thread management and context switching, especially under high load.

Node.js, on the other hand, uses a single-threaded event loop to manage multiple client requests. This means that the JavaScript code execution happens in a single thread. While this might initially seem like a limitation, the non-blocking nature of I/O operations ensures that Node.js can handle many simultaneous connections efficiently.

Non-Blocking I/O

Non-blocking I/O means that operations like reading from a file, writing to a database, or making network requests do not block the execution of other code. Instead of waiting for these operations to complete, Node.js uses an event-driven approach where a callback function is registered to handle the response once the operation finishes.

This allows Node.js to handle many I/O operations in parallel without requiring multiple threads, making it highly efficient for I/O-bound tasks.

How Does the Model Work?

Event Loop

At the heart of Node.js is the event loop, which is responsible for handling asynchronous operations. The event loop is a constantly running process that checks for pending tasks and executes them as they become ready. Here’s a simplified version of how it works:

• Initialize: The event loop starts by initializing the application, executing the main JavaScript code, and registering any event listeners or callbacks.
• Execute: Asynchronous operations are sent to the system kernel (e.g., file I/O, network requests). The event loop does not wait for these operations to complete; instead, it continues executing other code.
• Check: The event loop periodically checks for completed I/O operations. When an operation is completed, the associated callback function is placed in the callback queue.
• Process: The event loop processes the callbacks in the queue, executing the code in each callback.

Callbacks and Promises

Node.js relies heavily on callbacks and promises for handling asynchronous operations.

Callbacks: These are functions passed as arguments to asynchronous functions, which are executed once the operation completes.

const fs = require('fs');

fs.readFile('file.txt', 'utf8', (err, data) => {
  if (err) throw err;
  console.log(data);
});

Promises: These provide a cleaner way to handle asynchronous code, allowing chaining and better error handling.

const fs = require('fs').promises;

fs.readFile('file.txt', 'utf8')
  .then(data => console.log(data))
  .catch(err => console.error(err));

Asynchronous I/O Operations

Node.js uses asynchronous I/O operations extensively to prevent blocking the event loop. These operations typically involve interactions with external resources like files, databases, and network services.

const fs = require('fs');

fs.readFile('file.txt', 'utf8', (err, data) => {
  if (err) {
    console.error('Error reading file:', err);
  } else {
    console.log('File contents:', data);
  }
});

console.log('This will log before the file contents.');

Example

If we get requests from two users A and B. With non-blocking IO we can initiate the request for A and then immediately for B without waiting for the response to the request of A. Hence we can say with the help of non-blocking IO we can eliminate the use of multi-threading since the node server can handle multiple requests simultaneously.

Working of single-threaded non-blocking IO

• When the client sends a request to the server, this request is called an event. These all requests get stored in an event queue. The single thread present in the event loop assigns this request to one of the threads present in the internal thread pool.
• This thread reads the client request, processes the request, performs any blocking IO operations if needed, and prepares the final response to be sent back to the server. The event loop sends this response back to the respective client.
• The event loop infinitely receives requests and processes them.
• There is no need for multiple threads because of Event Loop. Because of this event loop and concept of single threading, node.js uses lesser resources and memory.

Reference: https://www.geeksforgeeks.org/node-js/node-js-introduction/