Skip to content

NodeJS Event Loop

Last Updated : 12 Feb, 2025

The event loop in Node.js is a mechanism that allows asynchronous tasks to be handled efficiently without blocking the execution of other operations. It:

Executes JavaScript synchronously first and then processes asynchronous operations.
Delegates heavy tasks like I/O operations, timers, and network requests to the libuv library.
Ensures smooth execution of multiple operations by queuing and scheduling callbacks efficiently.

Why Event Loop is important?

The Event Loop is essential in Node.js because it allows non-blocking, asynchronous operations to be handled efficiently, even though Node.js operates on a single thread.

Enables non-blocking execution despite Node.js being single-threaded.
Helps handle I/O-bound tasks efficiently.
Makes Node.js suitable for scalable applications like web servers.

Let's see a simple Asynchronous example

JavaScript

console.log("This is the first statement");

setTimeout(function() {
    console.log("This is the second statement");
}, 1000);

console.log("This is the third statement");

First statement is logged immediately.
setTimeout schedules the second statement to log after 1000 milliseconds.
Third statement is logged immediately after.
After 1000 milliseconds, the callback from setTimeout is executed, logging Second statement.

Output

This is the first statement
This is the third statement
This is the second statement

How the Event Loop Works?

When a Node.js application runs, the event loop starts, processes the synchronous code first, and then moves to handle asynchronous tasks. The execution follows these steps:

1. Initialization

When Node.js starts, it loads the script, executes synchronous code, and registers any asynchronous tasks (e.g., timers, I/O requests, network operations).

2. Execution of Input Script

The call stack executes synchronous code first.
Any asynchronous operations (setTimeout, fs.readFile, network requests) are delegated to libuv.

3. Handling Asynchronous Operations with libuv

Node.js uses a special C library called libuv to handle asynchronous operations. This library manages a thread pool that offloads heavy tasks (like file I/O, database operations, or network requests) that would otherwise block the event loop. The thread pool contains several threads that perform tasks like:

File system I/O (fs.readFile)
Network requests (HTTP, TCP, DNS)
Timers (setTimeout, setInterval)
Compression and cryptographic tasks

4. Callback Execution

Once the thread pool completes its tasks, it sends callbacks to the event queue. The event loop processes these callbacks, but only when the call stack is empty (i.e., when no synchronous code is currently executing).

5. Event Loop Phases

The event loop goes through multiple phases, each designed to handle a different set of operations. It checks for events, handles asynchronous callbacks, and executes tasks in the correct order.

6. Callback Execution from Event Queue

After the call stack is empty, the event loop picks tasks from the event queue and sends them to the call stack for execution. These tasks could include:

Completing network requests
Processing I/O events
Handling timers like setTimeout or setInterval

The following diagram is a proper representation of the event loop in a Node.js server:

Event Loop Working

Phases of the Event loop

The event loop in Node.js consists of several phases, each of which performs a specific task. These phases include:

Phases of the Event loop

1. Timers Phase

This phase processes timers that have been set using setTimeout() and setInterval().

JavaScript

console.log('Start');

setTimeout(() => {
    console.log('Timeout callback');
}, 2000);

console.log('End');

setTimeout() schedules a callback to run after 2000 milliseconds.
The event loop processes this callback in the timers phase after the synchronous code has executed.

Output:

Start
End
Timeout callback

2. Pending Callbacks

This phase executes I/O-related callbacks that were deferred from the previous loop cycle.

JavaScript

console.log('Start');

setImmediate(() => {
    console.log('Immediate callback');
});

console.log('End');

setImmediate() schedules a callback to run immediately after the current event loop cycle.
The event loop processes this callback in the pending callbacks phase.

Output:

Start
End
Immediate callback

3. Idle, Prepare (Internal use only)

This phase is used internally by Node.js for background tasks.

4. Poll Phase (Main Phase)

The Poll phase executes most of the tasks like- I/O, file reading, HTTP requests and much more.

JavaScript

const fs = require('fs');
const readStream = fs.createReadStream('./file.txt');

console.log('Start');

readStream.on('data', (chunk) => {
    console.log(chunk.toString());
});

console.log('End');

fs.readFile() initiates an asynchronous file read operation.
The callback is added to the poll phase and executed once the file read is complete.

Output:

Start
End
File read complete

5. Check Phase

This phase processes any setImmediate() callbacks that have been added to the message queue.

JavaScript

console.log('Start');

setImmediate(() => {
    console.log('Immediate callback');
});

console.log('End');

setImmediate() schedules a callback to run immediately after the poll phase.
The event loop processes this callback in the check phase.

Output

Start
End
Immediate callback

6. Close Callbacks Phase

This phase executes callbacks for closed connections like sockets, streams, and event emitters.

JavaScript

const net = require('net');
const server = net.createServer((socket) => {
    socket.on('close', () => {
        console.log('Socket closed');
    });
});

server.listen(8000);

The server listens for incoming connections.
When a socket is closed, the 'close' event is emitted, and the corresponding callback is executed in the close callbacks phase.

Output

Server listening on port 8000

process.nextTick() and Promises in the Event Loop

Apart from these phases there is also process.nextTick() and promise callback which has the highest priority in the event loop. It executes after every phase before moving to the next phase.

process.nextTick() callbacks are always executed before the event loop moves to the next phase.
Resolved Promise callbacks are processed immediately after process.nextTick().

Now you have seen all the phases so let's understand the order by using this code example

JavaScript

setImmediate(() => {
   console.log("setImmediate is called");
});

Promise.resolve("Promise is resolved").then(console.log);

setTimeout(() => {
   console.log("Time function is called");
}, 0);

process.nextTick(() => {
   console.log("Process.nextTick");
});

Output

Process.nextTick
Promise is resolved
Time function is called
setImmediate is called

In this example

process.nextTick() executes before moving to the next phase.
Resolved Promises execute right after process.nextTick().
setTimeout() executes in the timers phase.
setImmediate() executes in the check phase.

Node.js Event Loop : A Visual Explanation

NodeJS Modules

A

AritraSen

Improve

Article Tags :

Similar Reads

Node.js Tutorial

Node.js is a powerful, open-source, and cross-platform JavaScript runtime environment built on Chrome's V8 engine. It allows you to run JavaScript code outside the browser, making it ideal for building scalable server-side and networking applications.JavaScript was mainly used for frontend developme

`; $(commentSectionTemplate).insertBefore(".article--recommended"); } loadComments(); }); }); function loadComments() { if ($("iframe[id*='discuss-iframe']").length top_of_element && top_of_screen articleRecommendedTop && top_of_screen articleRecommendedBottom)) { if (!isfollowingApiCall) { isfollowingApiCall = true; setTimeout(function(){ if (loginData && loginData.isLoggedIn) { if (loginData.userName !== $('#followAuthor').val()) { is_following(); } else { $('.profileCard-profile-picture').css('background-color', '#E7E7E7'); } } else { $('.follow-btn').removeClass('hideIt'); } }, 3000); } } }); } $(".accordion-header").click(function() { var arrowIcon = $(this).find('.bottom-arrow-icon'); arrowIcon.toggleClass('rotate180'); }); }); window.isReportArticle = false; function report_article(){ if (!loginData || !loginData.isLoggedIn) { const loginModalButton = $('.login-modal-btn') if (loginModalButton.length) { loginModalButton.click(); } return; } if(!window.isReportArticle){ //to add loader $('.report-loader').addClass('spinner'); jQuery('#report_modal_content').load(gfgSiteUrl+'wp-content/themes/iconic-one/report-modal.php', { PRACTICE_API_URL: practiceAPIURL, PRACTICE_URL:practiceURL },function(responseTxt, statusTxt, xhr){ if(statusTxt == "error"){ alert("Error: " + xhr.status + ": " + xhr.statusText); } }); }else{ window.scrollTo({ top: 0, behavior: 'smooth' }); $("#report_modal_content").show(); } } function closeShareModal() { const shareOption = document.querySelector('[data-gfg-action="share-article"]'); shareOption.classList.remove("hover_share_menu"); let shareModal = document.querySelector(".hover__share-modal-container"); shareModal && shareModal.remove(); } function openShareModal() { closeShareModal(); // Remove existing modal if any let shareModal = document.querySelector(".three_dot_dropdown_share"); shareModal.appendChild(Object.assign(document.createElement("div"), { className: "hover__share-modal-container" })); document.querySelector(".hover__share-modal-container").append( Object.assign(document.createElement('div'), { className: "share__modal" }), ); document.querySelector(".share__modal").append(Object.assign(document.createElement('h1'), { className: "share__modal-heading" }, { textContent: "Share to" })); const socialOptions = ["LinkedIn", "WhatsApp","Twitter", "Copy Link"]; socialOptions.forEach((socialOption) => { const socialContainer = Object.assign(document.createElement('div'), { className: "social__container" }); const icon = Object.assign(document.createElement("div"), { className: `share__icon share__${socialOption.split(" ").join("")}-icon` }); const socialText = Object.assign(document.createElement("span"), { className: "share__option-text" }, { textContent: `${socialOption}` }); const shareLink = (socialOption === "Copy Link") ? Object.assign(document.createElement('div'), { role: "button", className: "link-container CopyLink" }) : Object.assign(document.createElement('a'), { className: "link-container" }); if (socialOption === "LinkedIn") { shareLink.setAttribute('href', `https://www.linkedin.com/sharing/share-offsite/?url=${window.location.href}`); shareLink.setAttribute('target', '_blank'); } if (socialOption === "WhatsApp") { shareLink.setAttribute('href', `https://api.whatsapp.com/send?text=${window.location.href}`); shareLink.setAttribute('target', "_blank"); } if (socialOption === "Twitter") { shareLink.setAttribute('href', `https://twitter.com/intent/tweet?url=${window.location.href}`); shareLink.setAttribute('target', "_blank"); } shareLink.append(icon, socialText); socialContainer.append(shareLink); document.querySelector(".share__modal").appendChild(socialContainer); //adding copy url functionality if(socialOption === "Copy Link") { shareLink.addEventListener("click", function() { var tempInput = document.createElement("input"); tempInput.value = window.location.href; document.body.appendChild(tempInput); tempInput.select(); tempInput.setSelectionRange(0, 99999); // For mobile devices document.execCommand('copy'); document.body.removeChild(tempInput); this.querySelector(".share__option-text").textContent = "Copied" }) } }); // document.querySelector(".hover__share-modal-container").addEventListener("mouseover", () => document.querySelector('[data-gfg-action="share-article"]').classList.add("hover_share_menu")); } function toggleLikeElementVisibility(selector, show) { document.querySelector(`.${selector}`).style.display = show ? "block" : "none"; } function closeKebabMenu(){ document.getElementById("myDropdown").classList.toggle("show"); }