Understanding the Event Loop: How Node.js Executes Asynchronous Callbacks

In Node.js, the event loop is a mechanism that handles asynchronous events. It is what allows Node.js to perform non-blocking I/O operations, despite the fact that JavaScript is a single-threaded language.

Here’s how it works:

1. The event loop starts when Node.js begins running.

At this point, Node.js sets up all of the necessary infrastructure for the event loop to function, such as creating the event queue and initializing any necessary variables.

2. Node.js starts a loop that listens for events.

This loop is what allows Node.js to continuously check for new events that need to be processed. The loop listens for events using various methods, such as setTimeout() and setInterval() for timers, and process.nextTick() for immediately executing a callback.

process.nextTick() is a way to tell the computer to do something as soon as possible, but not right this second. It’s kind of like when you tell your little sister to clean her room, but you don’t need her to do it right this second. You just want her to do it as soon as she can. process.nextTick() works the same way in a computer program. It tells the computer to do something as soon as it can, but not to stop everything it’s doing right now to do it.

3. When an event occurs, the event loop adds an event to the event queue.

The event queue is a data structure that stores events that need to be processed. When an event occurs, such as a connection request or a timer expiring, the event loop adds the associated callback function to the event queue.

4. If the event queue is empty, the event loop will continue to listen for events.

If there are no events in the queue, the event loop will continue to listen for new events. This allows Node.js to handle multiple events concurrently and avoid blocking the main thread.

5. If the event queue is not empty, the event loop will take the first event off the queue and execute the associated callback function.

If there are events in the queue, the event loop will take the first event off the queue and execute the associated callback function. This callback function will be executed in the main thread, which means that it will block any other events from being processed until it finishes executing.

6. When the callback function finishes executing, the event loop goes back to step 2 and listens for more events.

After the callback function finishes executing, the event loop goes back to step 2 and begins listening for more events. This process continues indefinitely, allowing Node.js to handle a large number of events asynchronously.

In addition to the event queue, the event loop in Node.js also makes use of callback queues and priority queues.

Callback queues: These queues store callbacks that have been scheduled to be run after the current iteration of the event loop has completed. Callbacks are added to the callback queue when the setImmediate() function is called. Callback queues, also known as “immediate” queues, are used to store callbacks that have been scheduled to be run after the current iteration of the event loop has completed.

Callbacks are added to the callback queue using the setImmediate() function, which schedules a callback to be run on the next iteration of the event loop. This is useful for scheduling non-time-sensitive callbacks that do not need to be run immediately, but should be run as soon as possible.

When the event loop finishes processing all of the events in the event queue, it checks the callback queue for any pending callbacks. If the callback queue is not empty, the event loop will take the first callback off the queue and execute it.

Here’s an example of how setImmediate() can be used:

setImmediate(() => {
  console.log('This callback will be run on the next iteration of the event loop');
});

Priority queues: These queues store high-priority events that need to be processed as soon as possible. For example, if a timer expires, the associated callback function will be added to the priority queue instead of the event queue. This ensures that time-sensitive events are processed as quickly as possible.

APIs: The event loop in Node.js also makes use of various APIs, such as the fs (file system) and net (network) modules, to handle events related to reading and writing files and creating and accepting connections. These APIs use non-blocking I/O operations, which means that they do not block the event loop while they are executing. This allows Node.js to handle multiple I/O operations concurrently and improve performance.

Different phases of event loop

The event loop has a number of phases that it goes through repeatedly in a loop. These phases include:

1. Timers phase: In this phase, the event loop checks to see if any scheduled timers (e.g. setTimeout or setInterval) have reached the time at which they should execute. If any timers are ready to be executed, the event loop adds their callback functions to the task queue.
2. I/O callbacks phase: In this phase, the event loop processes any callbacks that have been registered to be called in response to I/O events (e.g. a file being read from disk, or data being received over a network connection). These callbacks are added to the task queue.
3. Idle, prepare: These phases are internal phases that are not exposed to JavaScript code. They are used by the event loop to perform any necessary preparations before moving on to the next phase.
4. Poll: In this phase, the event loop retrieves the next task from the task queue and executes it. If the task queue is empty, the event loop will block and wait for new tasks to be added, or for a timer to expire.
5. Check: This phase is only run if the poll phase did not retrieve any tasks from the task queue. In the check phase, the event loop looks for any “microtasks” that have been queued (e.g. via the process.nextTick function in Node.js). If there are any microtasks, the event loop will execute them.
6. Close callbacks: This phase is only relevant in Node.js, and it involves executing any callbacks that have been registered to be called when a certain I/O resource is closed (e.g. a file or network connection).

The event loop then goes back to the timers phase and repeats the process. This continues indefinitely, until the program exits.

What is task and priority task queue in event loop

Tasks are added to the task queue, which is a FIFO (first-in, first-out) data structure that holds the tasks that are waiting to be executed.

The event loop goes through a number of phases, and in the poll phase, it retrieves the next task from the task queue and executes it. Once a task has been executed, it is removed from the task queue.

In addition to the task queue, there is also a concept of a “priority task queue.” This is a separate queue that holds tasks that are considered to have a higher priority than the tasks in the regular task queue. The priority task queue is processed before the regular task queue, so tasks in the priority queue will be executed before tasks in the regular queue.

Examples of tasks that might be placed in the priority task queue include:

• UI updates in a web browser
• I/O callbacks that are associated with real-time data streams (e.g. audio or video)

The specific implementation of the priority task queue will depend on the JavaScript runtime being used. In some runtimes, the priority task queue is implemented as a separate data structure, while in others, it may be implemented as a separate phase of the event loop.