What is Poll Phase in Node.js Event Loop ?

The Node.js event loop is the heart of Node.js, responsible for executing non-blocking I/O operations and enabling the asynchronous behavior that defines the platform. Among the various phases of the event loop, the poll phase plays a crucial role in handling I/O events. In this article, we'll delve into the details of the poll phase, understanding its purpose, functioning, and significance in the broader context of the Node.js event loop.

What is the Node.js Event Loop?

Before diving into the poll phase, let's briefly recap the Node.js event loop. The event loop is a mechanism that allows Node.js to perform non-blocking I/O operations by offloading operations to the system kernel whenever possible. It consists of multiple phases that sequentially handle different types of callbacks.

Here are the main phases of the Node.js event loop:

• Timers: Executes callbacks scheduled by setTimeout() and setInterval().
• Pending Callbacks: Executes I/O callbacks deferred from the previous loop iteration.
• Idle, Prepare: Internal use only, used for performance optimization.
• Poll: Retrieves new I/O events and executes I/O-related callbacks.
• Check: Executes callbacks scheduled by setImmediate().
• Close Callbacks: Executes close events, like socket.on('close').

The poll phase is particularly critical for handling I/O operations efficiently.

The Role of the Poll Phase

The poll phase primarily focuses on two tasks:

• Retrieving I/O Events: It checks for new I/O events that have occurred and adds them to the event queue.
• Executing Callbacks: It executes callbacks associated with I/O operations, such as reading from a file or receiving data from a network socket.

Functions of poll phase of the Node.js event loop

Determining how long to block and poll for I/O events

When the event loop enters the poll phase, it will block and wait for new events to be added to the poll queue. The length of time that the event loop blocks and waits for new events are determined by the value of the poll parameter in the setTimeout() function. If the value of the poll is -1, the event loop will block indefinitely until new events are available. If the value of the poll is a positive number, the event loop will block for that number of milliseconds before moving on to the next phase of the event loop.

Processing events in the poll queue

After the event loop has determined how long to block and poll for new events, it will iterate through the events in the poll queue and hand them off to the appropriate event handlers for processing. This is where most of the JavaScript code that you have written will be executed, starting at the top and working its way down through the code.

If there are no timers scheduled when the event loop reaches the poll phase, one of two things may happen:

• If the poll queue is not empty: the event loop will iterate through the queue, running the callbacks in the queue synchronously until the queue is exhausted or the system-dependent hard limit is reached.
• If setImmediate() was not used to schedule scripts: the event loop will wait for callbacks to be added to the queue before executing them.

What is Long Polling?

• Long polling is a technique used to establish a stable connection between a client and a server without using protocols such as WebSocket or Server-Sent Events. In long polling, the client sends a request to the server, and the server responds only when it has new and specific information. Until that time, the connection remains open.
• The client can then send another request as soon as the server responds, and the server will return a response when data is available. This process begins again when the client closes the connection and the server sends a request.
• In Node.js, long polling can be implemented by keeping the connection between the client and server open until the server has complete data to respond with. While the connection is open, the client is waiting for the server to respond with data before sending another request.
• Long polling can be configured on the client side by creating an event loop that sends requests to the server during periods of downtime or when making new requests.

Non-Blocking Nature of the Poll Phase

The non-blocking nature of Node.js is largely due to the poll phase. By efficiently handling I/O operations without blocking the main thread, Node.js can serve multiple clients concurrently, making it ideal for applications that require high I/O throughput, such as web servers or real-time data processing systems.

Installation Steps

Step 1: Make a folder structure for the project.

mkdir myapp

Step 2: Navigate to the project directory

cd myapp

Step 3: Initialize the NodeJs project inside the myapp folder.

npm init -y

Step 4: Install the required dependencies in your project.

npm install net

Project Structure

The updated dependencies in package.json file will look like:

"dependencies": {
    "net": "^1.0.2",
  }

Example: This example code demonstrates this whole polling  process:

// app.js

const net = require('net');

const server = net.createServer(socket => {
    // This function is the event handler 
    // for incoming connections.
    
    // It will be called for each new 
    //connection that is received.

    console.log('New connection received:', socket.remoteAddress);
    // ... handle requests from the client here ...
});

server.listen(3000, () => {
    console.log('Server listening on port 3000');
});

Output:

Server listening on port 3000
New connection received: [remote address]

In this example, the call to net.createServer() creates a new server and registers an event handler function to be called for each incoming connection. When the server is started using the listen() method, it begins listening for incoming connections on port 3000. When a new connection is received, the event handler function is called and passed a socket object representing the connection. This event is added to the poll queue, and the event loop will handle it during the poll phase.

Conclusion

The poll phase is a critical component of the Node.js event loop, responsible for handling I/O events and ensuring the non-blocking behavior that makes Node.js so powerful. By efficiently managing I/O operations and integrating seamlessly with other phases of the event loop, the poll phase enables Node.js to perform high-throughput, low-latency asynchronous operations, making it an excellent choice for building scalable and performant applications.