Nodejs Architecture And Event Loop Complete Guide

Introduction to Node.js Architecture

Node.js is built on Google Chrome's V8 JavaScript Engine (written in C++) and uses an event-driven, non-blocking I/O model. This makes it lightweight and efficient, suitable for data-intensive real-time applications that run across distributed devices.

Key Components of Node.js Architecture

1. Event Loop: The core part of Node.js that manages asynchronous operations using a callback queue.
2. V8 Engine: Executes JavaScript code. Every Node.js process has one thread running the V8 engine.
3. Libuv Library: Manages non-blocking socket I/O operations.
4. Node Standard Library: Bundles essential Node.js modules like HTTP, File System, Path, etc.
5. Callback Queue/Task Queue: Stores callbacks of asynchronous operations.
6. Timers, Microtasks, I/O: Manage different types of operations.

Step-by-Step Guide with Examples

1. Setting Up Node.js

First, install Node.js from nodejs.org.

2. Basic Node.js Application

Create a new file named app.js and run a simple console operation:

// app.js
console.log("This will be printed first");

setTimeout(() => {
    console.log("This will be printed after 1 second");
}, 1000);

console.log("This will be printed second");

Running the Application:

node app.js

Output:

This will be printed first
This will be printed second
This will be printed after 1 second

Explanation:

• console.log("This will be printed first") is executed immediately.
• setTimeout() schedules a function to run after 1000 milliseconds. Node.js throws this into the event loop.
• console.log("This will be printed second") is also executed immediately since there’s no delay.
• After 1 second, the timeout function is executed, printing “This will be printed after 1 second”.

3. Asynchronous File I/O

Using fs module to read a file asynchronously:

// app.js
const fs = require('fs');

console.log("Start reading the file...");

fs.readFile('example.txt', 'utf8', (err, data) => {
    if (err) {
        console.error(err);
        return;
    }
    console.log("File content:", data);
});

console.log("End of the script");

Create a File:

Create a file named example.txt with some text in it.

Running the Script:

node app.js

Example File Content (example.txt):

Hello, Node.js!

Expected Output:

Start reading the file...
End of the script
File content: Hello, Node.js!

Explanation:

• The fs.readFile() function reads the file asynchronously. It takes the filename and encoding as arguments.
• While the file is being read, the script continues to execute and prints "End of the script".
• Once the file reading is done, the callback function inside fs.readFile() is executed and the file content is displayed.

4. Event Loop: Timers, Microtasks, I/O

Consider the following example combining timers, microtasks, and I/O operations:

// app.js
setTimeout(() => console.log("Timeout"), 0); // Timer with 0 delay

process.nextTick(() => console.log("Next Tick")); // Microtask

Promise.resolve().then(() => console.log("Resolved Promise")); // Microtask (another form of microtask)

fs.readFile('example.txt', 'utf8', (err, data) => {
    if (err) {
        console.error(err);
        return;
    }
    console.log("File content:", data);
}); // I/O operation


console.log("Main Thread"); // Synchronous operation

Running the Script:

node app.js

Expected Output:

Main Thread
Next Tick
Resolved Promise
Timeout
File content: Hello, Node.js!

Explanation:

• Synchronous Operation:
  • console.log("Main Thread") runs first, because it's executed on the main thread without any delay.
• Microtasks:
  • process.nextTick() and Promise.resolve().then() are both microtasks.
  • Microtasks are executed immediately after the synchronous code, and they have higher priority than tasks.
  • Hence, "Next Tick" will be printed before "Resolved Promise".
• Timers:
  • setTimeout(() => {...}, 0) schedules the callback to be executed after the timer expires. However, since the timer delay is 0 milliseconds, the callback gets placed in the task queue.
  • Timers run after all microtasks have been processed.
  • So, "Timeout" is printed after "Next Tick" and "Resolved Promise".
• I/O Operations:
  • The file reading operation is placed in the libuv queue.
  • I/O operations are executed after timers.
  • Finally, "File content: Hello, Node.js!" is printed.

5. More Detailed Example: Mixing HTTP Server and Asynchronous Operations

Creating an HTTP server that performs asynchronous operations for each request:

// app.js
const http = require('http');
const fs = require('fs');

const server = http.createServer((req, res) => {
    console.log("Request received");
    
    fs.readFile('example.txt', 'utf8', (err, data) => {
        if (err) {
            console.error(err);
            res.writeHead(500, { 'Content-Type': 'text/plain' });
            res.end('Internal Server Error\n');
            return;
        }
        
        res.writeHead(200, { 'Content-Type': 'text/plain' });
        res.write("File content:\n" + data);
        console.log("File read and response sent");
    });

    setTimeout(() => {
        console.log("Timeout executed");
    }, 1000);

    console.log("Timeout scheduled");
});

server.listen(3000, () => {
    console.log('Server running at http://localhost:3000/');
});

Running the Script:

node app.js

Server Output When No Requests Are Received:

Server running at http://localhost:3000/

Server Output When a Request Is Received:

Request received
Timeout scheduled
File read and response sent
Timeout executed

Explanation:

• The server starts listening on port 3000.
• When a request comes, "Request received" is printed.
• fs.readFile() schedules an I/O operation to read the file.
• setTimeout() schedules a timer function to run after 1 second.
• Node.js continues processing other parts of the code and logs "Timeout scheduled".
• Once the file reading is complete, the server sends the file content in the response and logs "File read and response sent".
• After 1 second, the timer function executes and logs "Timeout executed".

Conclusion

Understanding how Node.js handles asynchronous operations through its event loop is crucial. In the above examples, you've seen how synchronous operations, timers, microtasks, and I/O operations are managed.

Always keep in mind the order of execution:

1. Synchronous Code
2. Microtasks (nextTick and promise resolution)
3. Timers
4. I/O Operations