Node.js Event Loop Explained

Summary

This video dives into the Node.js event loop, explaining its various stages and how they interact to handle asynchronous operations. It starts by detailing how the event loop runs continuously when a server is active, handling timers, callbacks, and other tasks. The video also covers the differences between microtasks and macrotasks, and their priorities in the loop. The creator emphasizes the importance of understanding these details for optimizing Node.js applications, and hints at future videos on improving performance and avoiding event loop blocking.

Takeaways

• 🔄 Node.js has an event loop that operates continuously, especially when running processes like a web server.
• ⏳ The first phase of the event loop is called 'timers', where functions like `setTimeout` and `setInterval` are checked and executed.
• 📋 Microtasks, such as `process.nextTick()` and promises, have higher precedence than macrotasks like timers and I/O operations.
• ⚙️ The V8 engine, which powers Node.js and browsers, separates tasks into microtasks and macrotasks, with microtasks running first.
• ⏱️ Inside the timers phase, microtasks and macrotasks run with their own order of precedence.
• ⏲️ The 'poll' phase of the event loop is crucial for handling incoming I/O operations such as network requests and file reads.
• 💻 Understanding the internal workings of the event loop helps in optimizing Node.js applications for performance.
• 🕒 The 'check' phase is specifically for handling `setImmediate`, which executes with higher precedence over other timers.
• ❌ The last phase, 'close callbacks', handles events like socket closures and cleanup operations.
• 📊 Optimizing Node.js performance involves reducing event loop lag and avoiding blocking operations, with strategies like using worker threads.

Q & A

What is the event loop in Node.js and when does it start?

The event loop in Node.js starts as soon as you run a Node.js script (e.g., `node index.js`). It is responsible for handling asynchronous operations, and it keeps running as long as there are tasks, such as web servers, waiting for events like incoming network connections.

What happens in the 'timers' phase of the Node.js event loop?

In the 'timers' phase, Node.js checks for and processes any scheduled functions that were set using `setTimeout` or `setInterval`. These are executed in the order they were set, based on their delay times.

What are microtasks and how do they differ from macrotasks in Node.js?

Microtasks have a higher priority than macrotasks and are executed before macrotasks in the event loop. Examples of microtasks include promise callbacks, `process.nextTick`, and `queueMicrotask`. Macrotasks include `setTimeout`, `setInterval`, and I/O operations like network requests.

What is the priority order for tasks within the 'timers' phase?

The priority order is: synchronous code, `process.nextTick` (next tick queue), microtasks (e.g., promise callbacks), and finally macrotasks (timers like `setTimeout` and `setInterval`).

What role do 'pending callbacks' play in the Node.js event loop?

The 'pending callbacks' phase handles callbacks from I/O operations that were deferred in the previous cycle of the event loop. These callbacks are executed in this phase after all timers and microtasks are processed.

What is the 'poll' phase and why is it considered the most important part of the event loop?

The 'poll' phase is where most of the asynchronous operations happen, such as incoming connections (HTTP, TCP) and file I/O. It checks for new events and handles them, making it critical for performance in a Node.js application.

What is the significance of 'setImmediate' in Node.js?

`setImmediate` is a special function in Node.js that schedules code to run at the next iteration of the event loop. It has a higher precedence than normal timers (`setTimeout`) and is executed in the 'check' phase.

What is the 'close callbacks' phase in the Node.js event loop?

The 'close callbacks' phase is the final step of the event loop, where it handles callbacks for closing events, such as when a TCP connection or file stream is closed.

Why is understanding the event loop important for Node.js developers?

Understanding the event loop helps developers write more efficient and optimized code by knowing how asynchronous tasks are handled, how to prevent blocking the event loop, and when to use certain functions like `setImmediate`, `process.nextTick`, and microtask queues.

What is 'event loop lag' and how can it affect the performance of a Node.js application?

Event loop lag occurs when long-running operations or synchronous code block the event loop, preventing it from handling other tasks. This can degrade the performance of a Node.js application, especially in cases involving high concurrency or heavy I/O.

Outlines

00:00

🌀 Understanding the Node.js Event Loop

The Node.js event loop is a fundamental yet often misunderstood aspect of Node.js, rarely covered in detail by videos or blogs. The event loop consists of multiple stages that occur rapidly while a Node.js application is running. This section introduces the concept, noting that as soon as a Node.js app is executed, the event loop begins. For small scripts, the loop may start and stop quickly, but for web servers, it persists, waiting for incoming events such as TCP connections. Understanding these details is crucial for leveraging Node.js effectively.

05:01

⏲️ Event Loop Stages and Timer Handling

This part delves deeper into the event loop, specifically focusing on the timer phase. It explains that Node.js checks for timers like `setTimeout` and `setInterval` during this phase. Through an example code with multiple timeouts and microtasks, the section introduces the concept of task queues—microtasks and macrotasks—highlighting their different priorities. Microtasks like promises and `process.nextTick()` take precedence over macrotasks like timeouts and intervals. The importance of understanding this hierarchy in developing efficient Node.js applications is emphasized.

10:03

🔄 Precedence and Task Queues in Node.js

Here, the script explains how task execution in Node.js is further subdivided into queues within each phase of the event loop. Tasks like `nextTick` are manually fired and take precedence even within `setTimeout`. This hierarchy is crucial for managing the flow of synchronous and asynchronous operations. The example illustrates how microtasks, promises, and other operations are prioritized, ensuring that developers understand how to manage task execution efficiently within the event loop.

📋 Pending Callbacks and Polling Phase

The focus shifts to the 'pending callbacks' phase and the 'poll' phase, which is where most asynchronous operations, such as network connections and file system reads, are handled. The poll phase plays a key role in ensuring the performance of a Node.js app. There’s a brief mention of optimizations, particularly how to avoid blocking the event loop and ensuring smooth operation. The video promises a follow-up on optimizing Node.js applications for performance by effectively managing these phases.

✅ The Check Phase and SetImmediate

This section introduces the 'check' phase, which is responsible for handling `setImmediate`, a function similar to `setTimeout` but with a higher precedence in the event loop. The script explains how `setImmediate` can either execute immediately during the poll phase or be deferred, depending on the system’s decisions. The final stage, 'close callbacks', is briefly mentioned, noting its role in managing events like socket closures.

👋 Wrapping Up and Future Topics

In the final paragraph, the speaker wraps up the video, reiterating that the discussion was an overview of the Node.js event loop. While optimizations and detailed explanations were not covered, the speaker promises a future video on how to optimize performance, particularly avoiding event loop lag. The video ends with a call to action for viewers to subscribe and await the next tutorial.

Keywords

💡Event Loop

The event loop is a core concept in Node.js that handles asynchronous operations. It continuously checks for tasks, executes them, and then waits for new tasks to arrive. In the video, it is explained as a looping process that starts with the node script and keeps running to manage operations like handling incoming connections, reading files, or managing timers.

💡Timers

Timers in Node.js, such as `setTimeout` and `setInterval`, are used to schedule tasks for future execution. In the event loop, the 'timers' phase checks if any timers are due to execute. The video explains how the event loop processes these timers and gives them priority based on whether they are synchronous or asynchronous.

💡Microtasks

Microtasks are tasks that have a higher priority in the Node.js event loop. They include promise callbacks, `process.nextTick()`, and mutation observers. The video emphasizes that microtasks take precedence over macrotasks, meaning they are executed before most other operations within each phase of the event loop.

💡Macrotasks

Macrotasks, also known as regular tasks, include `setTimeout`, `setInterval`, and I/O operations like network requests or file reading. In the video, macrotasks are described as lower priority compared to microtasks, and they are handled during the appropriate phase of the event loop, such as timers or poll.

💡Pending Callbacks

Pending callbacks are callbacks that were deferred from previous phases of the event loop, such as I/O operations that could not be completed immediately. The video explains how pending callbacks get executed after timers and how they are processed during the 'poll' phase.

💡Poll

The 'poll' phase in the event loop is responsible for executing most of the application’s I/O operations, such as handling incoming connections or reading files. It is one of the most critical stages, as described in the video, where the performance of the application is largely determined.

💡setImmediate

`setImmediate` is a special kind of timer in Node.js that is executed in the 'check' phase of the event loop. Unlike `setTimeout`, it has higher precedence and will execute after the poll phase completes. The video highlights this distinction, noting that `setImmediate` can provide more control over timing.

💡process.nextTick()

`process.nextTick()` is a method in Node.js that schedules a callback to be invoked in the next iteration of the event loop, but before any I/O tasks. It is treated as a microtask, giving it high priority. In the video, it's explained as a powerful tool for ensuring that critical code runs before other tasks.

💡Event Loop Lag

Event loop lag refers to a delay in the execution of tasks due to blocking operations, preventing the event loop from executing efficiently. The video briefly mentions how poorly optimized code can cause event loop lag, and how understanding the event loop helps developers avoid this issue.

💡Close Callbacks

Close callbacks are executed during the final phase of the event loop and handle tasks related to closing resources like socket connections. The video describes how these callbacks listen for 'close' events and ensure that resources are properly cleaned up when connections are terminated.

Highlights

Node.js Event Loop consists of multiple steps, occurring within milliseconds during the execution of a Node.js application.

When a Node.js app starts, the event loop initiates, running continuously unless the app terminates or a server is actively waiting for TCP connections.

The first step of the Event Loop is 'timers,' which handles functions like `setTimeout` and `setInterval`.

Microtasks and macrotasks have different levels of precedence in Node.js. Microtasks (like Promise callbacks and process.nextTick) are higher priority than macrotasks (like setTimeout, I/O operations, and event handlers).

The `nextTick` queue is manually triggered, and its tasks are executed first within a timeout, even before other microtasks and macrotasks.

Promise callbacks are considered microtasks, so they have a higher precedence and are executed before macrotasks like setTimeout or setInterval.

The 'poll' phase in the Event Loop is critical as it handles most I/O operations, including incoming HTTP or TCP connections, file reading, and more.

Pending callbacks are deferred tasks that were not executed in the previous cycle of the Event Loop and will be processed in the next round.

In the 'idle and prepare' phase, Node.js performs bookkeeping tasks, but it does not impact application performance or behavior.

SetImmediate has a higher precedence than setTimeout or setInterval and is executed during a specific step in the Event Loop.

The 'check' phase is where setImmediate is executed, giving it precedence over standard timers.

Close callbacks are triggered when a socket or any other connection is closed, allowing developers to clean up resources and manage disconnection events.

Understanding the internals of the Event Loop helps developers optimize Node.js applications and avoid blocking the Event Loop, ensuring high performance.

Event Loop lag is a critical issue to avoid, as it can delay execution of asynchronous tasks, degrading the performance of the Node.js application.

The speaker plans to release further content about optimizing Node.js performance, focusing on using worker threads and ensuring non-blocking operations.

Transcripts

we are missing some very important

knowledge about the event Loop of

node.js because I feel like this is not

really covered in many videos and blog

articles but nodejs event Loop actually

consists of many steps that are going

through that are happening within every

millisecond when you are running a no JS

app so let's talk about this and what

are the implications and what you need

to be aware of so first of all nodejs

does have an event Lo okay if you go to

the official noj website you will see

that there's a big article on how the

event Loop Works actually and the all

the steps that we're going to talk about

now so let's go back to the Blackboard

and this round figure that you see here

that goes clockwise is basically an

event Loop that starts as soon as you

run a node script okay you run node

index.js your app starts and as soon as

your app starts or the process starts

the loop starts as well well now the

thing is if you only have a very few

lines of code within your index.js file

let's say you're just doing a console

log or something like that the app is

going to start the event Lo is going to

start as well and then it's going to

close it's going to exit because your

process stopped there's nothing that we

need to listen to on the other hand if

you're starting a web server as you know

when you start the web server you do

this thing server. listen and under the

hood it basically waits for TCP

connections and the event Loop does not

stop it just keeps going and it's

basically going through these all steps

waiting for some events to happen and

this is the crucial part of

understanding how the event Loop works

okay so let's call this one the event

Loop e l just so that we know what we're

referring to so as soon as the event

Loop starts we are going to go all of

these over all of these steps like many

times within one second okay so what is

happening in the very first step called

timers well it turns out that nodejs is

checking for timers that are available

okay so if you have done a a timeout set

set timeout or set interval they're are

going to be handled within this uh part

here in in set timeouts or in the timer

section okay let's look at this piece of

code and understand what

has precedence when we are in this step

timers okay so we're going to see that

we have a console log or first of all we

have three timeouts we have a console

loog set timeout one then we have a

resolve and reject and then we have some

function called q microtask and then we

have nexti what are these because if you

go for a normal no JS tutorial video

you're not going to know anything about

this this is like very lowlevel node.js

stuff but let me explain I think if you

are using node.js as your tool to

accomplish your business needs the

better you know the underlying

Technologies of your tool or how it

works under the hood the better equipped

you are okay so it turns out let me

switch to another page uh nodejs or

basically the engine V8 engine that

nodejs is based upon it's it applies the

same for the browsers um they have

microt tasks and macro tasks meaning

microt tasks are more important so they

have higher priority than M microtasks

microtasks include promise callbacks

mutation observe API uh process.

nexttick which is a method that we can

fire manually within nodejs Q microtask

function that we basically sew and

weight Expressions on the other hand

microtasks or macro tasks consist of set

timeouts set intervals D manipulation IO

operations for example reading a file

Network requests and event handlers now

what does it mean for us so in this

timeout we're going the president is

going to be like the following so we

enter the timeout okay we're going to

log the first thingy because conso loog

is actually synchronous so we're going

to stumble upon this and it's going to

be locked out next what what's going to

happen are we going to L out the

promises or are we going to look out the

Q microtask or the next tick this is a

very interesting question and the answer

is actually here so we have these three

bubbles here which are also kind of a

loop within the loop all right and all

of these three bubbles actually are

living within every step that we have

here so they're inside the timers

they're also inside the pending call

bags they're also inside the pole so

they are running under every step and

they also have a precedence okay I know

this is confusing but first of all we

have these steps and then we have a

precedence within each queue so the next

TI queue is the one that we are firing

manually okay here for example we do

next tick and then we do console log so

that's going to fire first meaning

within our set timeout we're going to

get next tick one first the next thing

that's going to happen is we're going to

look for microtasks microtasks are the

ones that we already discussed for

example promises so promises are going

to have a higher precedence and then we

are going to fire the Q microtask which

also basically related to a microtask

and then we're going to look for the

macro tasks okay in this case we don't

have any macro tasks in this piece of

code but you can imagine that it will

fire next as soon as these all three are

done within our first timeout and

remember that we're still in this

section here we're going to jump to the

second time out so basically event Loop

starts we go to the timers section and

the timers also have its own precedence

so it's going to make sure that

everything has run here has around here

and then has around here and then we

jump to the next basically function

within the timers and as soon as these

are done now the event Lo can proceed to

pending callbacks what is pending

callbacks basically every time we're

going to come to this the poll section

is pretty much the most important one

it's the one that executes most of the

stuff including the synchronous stuff

okay sometimes poll does not poll stage

does not execute things and it defers

them it defers them to the next round

trip of the event Loop and sometimes

basically from the previous round things

end up here pending callbacks for

example a timeout can end up there for

one or other reason so so as you know

pending callbacks are going to as I

mentioned also have this precedence of

three different types of cues and it's

going to execute them one by one as soon

as the pending callbacks have been

executed we're going to jump to the next

section called idle and prepare there's

nothing to cover there because it is

it's native to V8 or nodejs and it's

basically doing some bookkeeping under

the hood to make sure that we're intact

so there's no impact for us when it

comes to the optimizations that we can

make okay so the next point will be poll

as I said this is the most important one

why because this is where the incoming

connections for example uh HTTP or TCP

connections that are being established

socket connections and so on file

reading all the synchronous stuff is

going to happen here and this is exactly

where we need to make sure that our

basically our app is performant wor not

I'm going to release another video as

soon as possible probably most after

this one in order to learn how to

actually make your node.js app

performance do you do you need new

worker threats do you need how do you

make everything asynchronous and most of

all

how basically how not to block the event

Loop and there's a thing called uh event

Loop lag basically when your operations

are executed with a small like it's

really hard to control that and I'm

going to cover that in the next video as

well so stay tuned And subscribe if you

haven't yet now we covered the polling

okay so we're going to execute mple

tasks here and then we also have a thing

called check okay what is a check well

we're basically checking for one and

only thing think called set set

immediate yeah you might not heard heard

about that we have set inter set timeout

set interval and we also have a set

intermediate here it works the same way

as a set timeout or sent interval but

the difference is that it has a presence

because it's happening within the event

Loop so basically if you have a set

inter immediate in your code it's going

to be executed right here on the other

hand set timeout can either be executed

in a timers depending on what what your

operating system decides during the poll

event or it can be deferred to the next

round okay so set immediate basically

has a higher precedence than other

timers and then we also have the last

step called close callbacks basically

these are going to listen for uh close

events for example when you're closing

the socket connection or when you are

manually closing the call bags or uh

removing the call bags this is it what I

wanted to tell you guys in this video

this is was this was just an rough

overview of the internals of the event

Loop of nodejs and as I said all the

optimizations optimization topics are

going to be covered in the next video so

smash like subscribe and I will see you

in the next one goodbye