Introduction to NodeJS, A SSJS: Part II - EventLoop Explained

1. When an event occurs, the corresponding event message is queued into the EventLoop
2. The Event Loop is checked for the message existence, if an event message exists then the corresponding callback is fired.
3. Once the callback is done with the job, control is returned to the event loop that continues from Step 2.

Note: if the JavaScript runtime is engaged with the event message, then the other messages must wait until the current message is done with the job. Sometimes you might get the browser saying something like “Browser is not responding”. This is because of the long-running event message. So try to keep the event messages as short as possible.

For example:

In this example above, we have attached the click event to the anonymous function as the event handler. When we clicked on that msg element, an event message is queued into the Event Queue.

If there are messages in the queue, then the click event message waits for the other messages to be done. All the other messages are processed, the over click event message is processed and the result is rendered into the DOM.

So we are somewhat clear about the JavaScript's Event Loop. Let us move onto the NodeJS EventLoop.

NodeJS EventLoop

As stated by Unknown, “Everything runs in parallel; except your code”. Yes, your code runs synchronously but the operations given by the code run by Node is asynchronous.



The preceding figure shows the event loop architecture of NodeJS.

1. When a request arrives, it is queued up into the EventLoop with a JavaScript Closure that includes the event (request, response) and corresponding callback.
2. The event is then given to the one worker thread if the job seems to take a long time to complete that is from a C++ Thread Pool, handled by the libuv library.
3. Once the job is done, the corresponding callback is fired to return back the response to the Main thread.
4. The Event Loop returns the response to the client.

For example:

The execution flow goes as in the following:

1. Our code tells the node to do the two tasks read() and write() and then takes a rest.
2. The read() and write() operations are enqueued into the Event Loop and distributed the job to the worker thread.
3. Once the worker threads are done with the job, it will fire the callbacks to return the response to the Event Loop.
4. Then the Event Loop returns the response to the client.

The callbacks of read() and write() will be executed in order to which one completes first. But note that only one of the callbacks would be executed at a time. So that the Node environment ensures that there won't be a deadlock or race condition. So it makes sure that the NodeJS provides Non-blocking IO.

We could consider the Post Office environment for the NodeJS.

When we post (request) something, the Post Master (Node) asks Post Men to deliver (get the job done) the post to the corresponding address.

Once the post men deliver the posts, they are reporting to the Post Master that it's completed, one by one.

Even the Post Master may assign some work to the post man at the time of reporting if he is free.

Conclusion

Finally, I am happy that I am able to explain for you the NodeJS's EventLoop. Please comment if you disagree on some points or are interested in learning more about the points explained. In my next part, we will discuss when to use and why to use NodeJS.

Thanks for Reading. Happy Coding.