Event Loop in Node.js

What is Node.js?

Leveraging Chrome's JavaScript runtime, Node.js is a platform for quickly building scalable network applications. It provides an occurrence-driven, non-blocking I/O method for data-intensive real-time applications that run across scattered devices, keeping it lightweight and effective. It is open-source and free to use. It also provides an excellent development environment, which makes it the ideal framework for web-based apps. A large developer community for Node.js also constantly creates new libraries as well as modules to aid with development.

Because Node.js applications are written in JavaScript and can run on Mac OS X, Windows, and Linux, they are completely cross-platform. Due to its event-driven architecture & non-blocking I/O strategy, Node.js is compact and efficient. It is perfect for distributed, data-intensive real-time applications because of these features. There are several considerations to make when developing Node.js apps. Since Node.js is asynchronous, you should first use promises, async functions, callbacks, or events to manage data flow. Second, you must be careful not to stall the thread by doing time-consuming operations since Node.js currently solely supports a single thread.

Become a master of Node.JS by going through this HKR Node.JS Training !

What is the Event Loop?

Threads

Before understanding Event Loop, it is important to understand Threads. When we start a programme, we generate an example of it, and we have internal components known as threads attached to that instance. A thread can be thought of as a group of tasks that our CPU must carry out on our behalf. The OS scheduler, a component of our operating system, is in charge of managing the scheduling mechanism, which is utilised to decide which thread to run at any given time.

Event Loop

A thread is created automatically each time a Node programme is executed. The only thread in which the entirety of our codebase will be run is this one. The so-called event loop is created inside of it. This loop's function is to schedule the tasks that our single thread should be working on at any given moment.

Please take note that even when we execute our programme immediately, the event loop doesn't appear right away. In actuality, it doesn't start until the entire application has finished running.

The following are some of the features of the Event Loop:

• An event loop is a never-ending cycle that awaits tasks, completes them, and thereafter sleeps until additional tasks are delivered.
• Only after the call stack is empty, or when there are no running tasks, does the event loop begin to process tasks from the event queue.
• We can use promises and callbacks with the event loop.
• The tasks in the event loop are carried out in reverse chronological order.

Nodejs Event Loop Architecture

Let us try to understand the Node.js Event Loop working via an example:

Example:

console.log("XYZ");
 
setTimeout(function(){
 console.log("ABC");
}, 1000);
 
console.log("DEF");

Output:

XYZ
DEF
ABC

In the aforementioned example, the task is eliminated from the call stack once the first console log statement is sent to it, logging "XYZ" on the console and pushing the task to the call stack. The job is then delivered to the operating system, and the setTimeout is added to the queue, and also the timer for the task is set. After that, this job is eliminated from the stack. The task is then popped off the stack when the third console log statement is sent to the call stack and "DEF" is printed to the console.

Whenever the timer defined by the setTimeout function (in this example, 1000 ms) expires, the callback is sent to the event queue. The event loop takes the task at the head of the event queue & feeds it to the call stack whenever the call stack is empty. The instruction is carried out by the callback function of the setTimeout function, which also removes the task from the stack and logs the message "ABC" on the console.

Working

Node.js commences running the event loop after initializing the event loop, parsing the input script that may include async API calls, and scheduling timers. The initial input script for the previous example contained console.log() statements as well as a setTimeout() function to set a timer.

A unique library module named libuv is used by Node.js to carry out async activities. The libuv thread pool is a unique thread pool that is managed by this library and the back logic of Node. Four threads from this pool are utilised to delegate tasks that are too complex for the event loop. Examples of these operations are I/O activities, opening and closing connections, and setTimeouts.

A callback function is invoked whenever the thread pool wraps up a task, and it deals with errors (if any) or performs other actions. The event queue receives a callback function like this one. The event moves through the event queue and delivers the callback to the call stack when the call stack is empty.

Want to know more about Node.Js, visit here Node.Js Tutorial !

Phases of the Event Loop

Let us now learn about the different phases of the event loop in more detail.

• Timers: The event loop begins processing any callback functions from expired timers first. If a timer expired later while one of the other phases was getting processed, the callback function for that timer will only be invoked when the event loop returns to the first phase. As a result, each queue's callbacks are handled one at a time until there are none left; only then will the event loop go on to the following stage.
• Pending Callbacks: The event loop runs any system-related callbacks during this phase. For instance, if you are developing a node server but another process is already using the port you wish to use to execute the process, the node will produce an error. ECONNREFUSED, some *nix systems might prefer the callback wait for execution because the system software is handling other duties. As a result, these callbacks are added to the execution queue for pending callbacks.
• Idle, Prepare: This phase is for cleaning up. The Event Loop does any callbacks' internal operations during this phase. Technically, neither the length of this period nor its direct influences are conceivable. There is no mechanism in place to ensure code execution throughout this stage. It is mostly used to gather data and plan what has to be done at the Event Loop's subsequent tick.

• Poll: The event loop keeps an eye out for brand-new async I/O callbacks during this stage. Except for the setTimeout, setInterval, setImmediate, and closing callbacks, almost all callbacks are executed.

In essence, the event loop performs two tasks during this stage:

1. It will carry out any callbacks that are already queued up in the poll phase callback queue until all callbacks have been cleared from the poll phase callback queue.
2. The event loop will remain in the poll phase for a while if there are currently zero callbacks in the queue. This "some time" is also dependent on the following factors:
1. The event loop will not stay in the poll phase for very long should there be any callbacks waiting to be processed in the setImmediate queue; instead, it will go to the Check/setImmediate phase. Once more, until the Check/setImmediate phase callback queue is empty, it will begin performing callbacks.
2. Whenever the event loop learns that timers have expired and their callbacks are pending to be executed, that is the second situation in which it will leave the poll phase. The event loop will then proceed to the Check/setImmediate phase, the Closing callbacks phase, and finally, the timers phase to begin its next iteration.

Top 30 frequently asked Node.JS Interview Questions !

• Check: The event loop in this phase starts executing each callback that was placed on the queue during the Check phase one at a time till the queue is clear. Once the poll phase gets idle and when there are no more callbacks that need to be executed, the event loop will enter this phase. Typically, during this stage, setImmediate callbacks are carried out.
• Close Callbacks: The event loop runs the callbacks connected to the closure events during this phase, such as socket.on('close', fn) or process.exit ().

Monitoring the Event Loop

It is clear that the event loop regulates all activities within a Node application. This indicates that if we are able to extract measurements from it, they ought to give us useful details about the overall performance and health of an application.

Any monitoring tool needs to provide its own metrics since there is no API for getting runtime data from the event loop. This is what we came up with:

• Tick Frequency: The rate of ticks per second.
• Tick Duration: The length of a tick.