Node.js Event Loop Explained: Microtasks, Macrotasks & Async Execution

Node.js Event Loop Deep Dive: Understanding Microtasks, Macrotasks, and Async Execution

Node.js | JavaScript | Backend Development | Advanced Tutorial

Why does Node.js handle thousands of concurrent requests without creating a separate JavaScript thread for every request?

The answer lies in its event-driven architecture and the Event Loop. Understanding the Event Loop helps developers write responsive APIs, avoid blocking operations, diagnose performance problems, and build scalable backend applications.

In this tutorial, we will explore the Event Loop phases, microtasks, macrotasks, Promises, process.nextTick(), setImmediate(), the libuv thread pool, and practical execution-order examples.

1. What Is the Node.js Event Loop?

Node.js is a JavaScript runtime built on the V8 JavaScript engine. It uses an event-driven, non-blocking I/O model to handle asynchronous operations.

Nodejs Event Loop Explained
 Node.js Event Loop Explained: Microtasks, Macrotasks & Async Execution

JavaScript code normally executes on the main JavaScript thread. When an operation such as a file read, network request, or timer needs to happen asynchronously, Node.js can delegate the work to the operating system or its underlying runtime facilities.

When the operation completes, its callback becomes eligible to execute. The Event Loop coordinates when eligible callbacks are executed.

Important concept The Event Loop does not make JavaScript execute multiple callbacks simultaneously on the same main JavaScript thread. It coordinates asynchronous work so that the thread can continue processing other tasks while I/O is pending.

Why Is the Event Loop Important?

  • It helps Node.js handle concurrent I/O operations efficiently.
  • It prevents waiting for many I/O operations from blocking JavaScript execution.
  • It helps developers understand callback execution order.
  • It is essential for building scalable APIs and backend services.
  • It helps identify event-loop blocking and performance bottlenecks.

2. How Asynchronous Execution Works

Consider an application that needs to read a file. A synchronous file operation blocks the JavaScript thread until the operation finishes. An asynchronous operation allows JavaScript to continue executing other code while the file operation is in progress.

Synchronous Example

JavaScript — Synchronous file reading
const fs = require('node:fs');

console.log('Start');

const data = fs.readFileSync('sample.txt', 'utf8');

console.log(data);
console.log('End');

In this example, readFileSync() blocks execution until the file has been read.

Asynchronous Example

JavaScript — Asynchronous file reading
const fs = require('node:fs');

console.log('Start');

fs.readFile('sample.txt', 'utf8', (error, data) => {
  if (error) {
    console.error(error);
    return;
  }

  console.log(data);
});

console.log('End');
Possible output
Start
End
File content

The callback runs after the file operation completes. Meanwhile, JavaScript can execute the remaining synchronous statements.

Key takeaway Asynchronous I/O improves application responsiveness because JavaScript does not need to wait synchronously for every I/O operation to finish.

3. Understanding the Node.js Event Loop Phases

The Node.js Event Loop has several phases. Each phase has a specific responsibility and processes particular types of callbacks.

The main phases are:

  1. Timers
  2. Pending Callbacks
  3. Idle, Prepare
  4. Poll
  5. Check
  6. Close Callbacks
Simplified Event Loop Phase Flow
1. Timers
↓
2. Pending Callbacks
↓
3. Idle / Prepare
↓
4. Poll
↓
5. Check
↓
6. Close Callbacks

The Event Loop continues cycling while there is work that keeps the process active. This is a simplified conceptual flow, not a complete representation of every internal transition.

3.1 Timers Phase

The Timers phase executes callbacks scheduled by:

  • setTimeout()
  • setInterval()

For example:

JavaScript — Timer callback
console.log('Start');

setTimeout(() => {
  console.log('Timer executed');
}, 1000);

console.log('End');
Output
Start
End
Timer executed

The timer delay is a minimum threshold, not an exact execution guarantee. If the Event Loop is busy, the callback may execute later.

3.2 Pending Callbacks Phase

This phase executes certain I/O callbacks deferred from previous Event Loop iterations. Some system-level error callbacks, such as specific TCP error handling callbacks, can be processed here.

Most application developers do not need to schedule work directly into this phase. Node.js and its underlying runtime manage it internally.

3.3 Idle and Prepare Phase

These phases are primarily used internally by libuv. They help the runtime prepare for the next iteration of the Event Loop.

Application code normally does not interact with these phases directly.

3.4 Poll Phase

The Poll phase is responsible for retrieving and processing I/O-related events. It is an important part of Node.js asynchronous execution.

For example, callbacks associated with completed file-system or network operations may be processed as part of the Event Loop's I/O handling.

The Poll phase can:

  • Process available I/O callbacks.
  • Wait for new I/O events when appropriate.
  • Move execution toward the Check phase when eligible immediate callbacks are waiting.

3.5 Check Phase

The Check phase executes callbacks scheduled with setImmediate().

JavaScript — setImmediate()
console.log('Start');

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

console.log('End');
Output
Start
End
Immediate callback

3.6 Close Callbacks Phase

This phase handles certain close-related callbacks, such as a socket's close event.

JavaScript — Socket close event concept
socket.on('close', () => {
  console.log('Socket connection closed');
});

When the socket closes, the corresponding close event callback is handled through Node.js's close-event processing.

4. Microtasks vs. Macrotasks

One of the most important concepts in asynchronous JavaScript is the difference between microtasks and other scheduled callbacks, often informally called macrotasks.

Microtasks are processed at microtask checkpoints. In Node.js, Promise reactions and queueMicrotask() callbacks use the microtask queue. Node.js also has a separate process.nextTick() queue.

Category Examples Execution behavior
Next Tick Queue process.nextTick() Processed at Node.js next-tick checkpoints.
Microtask Queue Promise.then(), queueMicrotask() Processed at microtask checkpoints.
Timer callbacks setTimeout(), setInterval() Eligible during timer processing.
Check callbacks setImmediate() Executed in the Check phase.
I/O callbacks Asynchronous I/O operations Processed through I/O event handling.

Microtask Example

JavaScript — Promise microtask
console.log('Start');

Promise.resolve().then(() => {
  console.log('Promise callback');
});

console.log('End');
Output
Start
End
Promise callback

The Promise callback does not execute immediately. It runs after the current synchronous JavaScript execution finishes, at a microtask checkpoint.

queueMicrotask() Example

JavaScript — queueMicrotask()
console.log('Start');

queueMicrotask(() => {
  console.log('Microtask executed');
});

console.log('End');
Output
Start
End
Microtask executed
Developer tip Use queueMicrotask() when you need to schedule a microtask without creating a Promise. It is also available in browsers, making it useful for portable JavaScript code.

5. process.nextTick() vs Promise.then()

Node.js provides process.nextTick() to schedule a callback for execution at the next-tick checkpoint.

Although it is often discussed alongside microtasks, it is important to understand that Node.js maintains a separate next-tick queue.

Example: CommonJS Execution

JavaScript — CommonJS example
console.log('Start');

process.nextTick(() => {
  console.log('Next Tick');
});

Promise.resolve().then(() => {
  console.log('Promise');
});

console.log('End');
Expected output in a CommonJS module
Start
End
Next Tick
Promise

In this CommonJS example, the next-tick callback is processed before the Promise reaction at the relevant checkpoint.

Important Difference in ES Modules

Execution ordering can differ when the same kind of example runs in an ES module. ES module evaluation itself involves Promise-based module processing, which affects the observed ordering.

For example, the following code can produce a different ordering when executed as an ES module:

JavaScript — ES module example
console.log('Start');

process.nextTick(() => {
  console.log('Next Tick');
});

Promise.resolve().then(() => {
  console.log('Promise');
});

console.log('End');
Typical ES module output
Start
End
Promise
Next Tick
Important Do not memorize one execution order as a universal rule without considering the module system and execution context. Test examples using the same Node.js version and module format as your application.

When Should You Use Each?

API Typical use Recommendation
process.nextTick() Node.js-specific next-tick scheduling. Use only when its specific scheduling behavior is needed.
Promise.then() Asynchronous Promise workflows. Use for Promise-based operations.
queueMicrotask() Scheduling a microtask directly. Useful for general microtask scheduling.

Excessive recursive use of process.nextTick() can prevent the Event Loop from progressing to other work. Prefer the scheduling mechanism that matches the actual requirement.

6. setTimeout() vs setImmediate()

Both APIs schedule callbacks asynchronously, but they are associated with different Event Loop processing stages.

  • setTimeout() schedules a callback after a minimum delay.
  • setImmediate() schedules a callback for the Check phase.

Example: Top-Level Scheduling

JavaScript — Timer vs Immediate
setTimeout(() => {
  console.log('Timeout');
}, 0);

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

When both are scheduled from the top level, the relative order can vary depending on timing and runtime conditions. Do not rely on a fixed order.

Example: Scheduling Inside an I/O Callback

JavaScript — I/O callback scheduling
const fs = require('node:fs');

fs.readFile('sample.txt', () => {
  setTimeout(() => {
    console.log('Timeout');
  }, 0);

  setImmediate(() => {
    console.log('Immediate');
  });
});
Expected ordering in this I/O callback example
Immediate
Timeout

The immediate callback is scheduled for the Check phase following the I/O callback. The zero-delay timer is handled during timer processing, so the immediate callback generally runs first in this context.

Remember Use setImmediate() when you specifically want to schedule work for the Check phase. Use timers when you need delay-based scheduling.

7. Understanding Execution Order with Practical Examples

Let's combine synchronous code, next-tick callbacks, Promise microtasks, timers, and immediate callbacks.

Example 1: Mixed Asynchronous Operations

JavaScript — Execution order
console.log('1. Start');

setTimeout(() => {
  console.log('2. Timeout');
}, 0);

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

Promise.resolve().then(() => {
  console.log('4. Promise');
});

process.nextTick(() => {
  console.log('5. Next Tick');
});

console.log('6. End');

For this CommonJS example, the synchronous statements execute first. At the next-tick checkpoint, Node.js processes the next-tick callback and then Promise microtasks.

Guaranteed initial sequence
1. Start
6. End
5. Next Tick
4. Promise
Remaining callbacks

The relative order of Timeout and Immediate can vary when scheduled from the top level.

Example 2: Nested Microtasks

JavaScript — Nested Promise callbacks
console.log('Start');

Promise.resolve().then(() => {
  console.log('Promise 1');

  Promise.resolve().then(() => {
    console.log('Promise 2');
  });
});

Promise.resolve().then(() => {
  console.log('Promise 3');
});

console.log('End');
Output
Start
End
Promise 1
Promise 3
Promise 2

Promise callbacks are processed in queue order. The nested Promise callback is added when the first Promise callback runs, so it follows the already queued third callback.

Example 3: Recursive nextTick Scheduling

JavaScript — Recursive nextTick
let count = 0;

function scheduleNextTick() {
  if (count < 3) {
    count++;

    console.log('Next Tick:', count);

    process.nextTick(scheduleNextTick);
  }
}

scheduleNextTick();

setTimeout(() => {
  console.log('Timer executed');
}, 0);
Output
Next Tick: 1
Next Tick: 2
Next Tick: 3
Timer executed

Next-tick callbacks are processed before the Event Loop proceeds to timer processing in this example.

8. What Is the libuv Thread Pool?

Node.js uses libuv as its cross-platform asynchronous I/O library. libuv provides Event Loop functionality and a worker thread pool for certain operations.

The thread pool is separate from the main JavaScript thread. It allows some operations to execute without blocking JavaScript while the operation is being processed.

Operations That Can Use the Thread Pool

  • Many file-system operations.
  • Some DNS operations, including dns.lookup().
  • Some cryptographic operations.
  • Compression operations provided by zlib.
Important distinction Not every asynchronous operation uses the libuv thread pool. Network I/O is generally handled using operating-system facilities rather than by assigning every network operation to a thread-pool worker.

Default Thread Pool Size

The default libuv thread pool size is four workers. You can configure it using the UV_THREADPOOL_SIZE environment variable before the process starts.

Terminal — Configure thread pool size
UV_THREADPOOL_SIZE=8 node app.js

On Windows command prompt, you can set the environment variable before starting Node.js using the appropriate command for your shell.

Increasing the thread pool size is not automatically a performance improvement. The right value depends on workload, available CPU resources, memory, and the operations being performed.

9. Blocking vs Non-Blocking Operations

A blocking operation prevents the main JavaScript thread from continuing until the operation finishes. A non-blocking operation allows JavaScript to continue while asynchronous work is pending.

Blocking operation Non-blocking alternative
fs.readFileSync() fs.readFile()
execSync() exec()
crypto.pbkdf2Sync() crypto.pbkdf2()

How Blocking Affects an API

Imagine a Node.js API that handles requests from many users. If one request triggers a CPU-heavy synchronous operation, the main JavaScript thread cannot process other JavaScript callbacks until that operation completes.

This can increase response times for unrelated requests.

Production warning Avoid long-running synchronous operations inside request handlers. They can create latency spikes and make an otherwise asynchronous application appear unresponsive.

Using Worker Threads for CPU-Intensive Work

For CPU-intensive JavaScript tasks, Node.js provides the Worker Threads API. Worker threads can execute JavaScript in separate threads, allowing CPU-heavy work to run without occupying the main JavaScript thread.

JavaScript — Main thread using Worker
const { Worker } = require('node:worker_threads');

const worker = new Worker('./worker.js');

worker.on('message', (result) => {
  console.log('Worker result:', result);
});

worker.on('error', (error) => {
  console.error('Worker error:', error);
});

worker.on('exit', (code) => {
  if (code !== 0) {
    console.error('Worker stopped with exit code', code);
  }
});
JavaScript — worker.js
const { parentPort } = require('node:worker_threads');

let result = 0;

for (let i = 0; i < 1000000; i++) {
  result += i;
}

parentPort.postMessage(result);

This example demonstrates the basic Worker Threads communication pattern. In production, consider worker lifecycle management, error handling, and worker pools rather than creating unlimited workers for individual tasks.

10. Event Loop Changes in Node.js 20

Node.js 20 introduced an important change through libuv 1.45.0. Timer processing behavior changed so that timers are run after the Poll phase rather than both before and after Poll as in earlier behavior.

This change can affect the relative execution order of timers and immediate callbacks in certain situations.

Why should developers care? Avoid depending on undocumented or environment-sensitive ordering between timers and immediate callbacks. Use the API that matches your scheduling requirement and verify behavior against the Node.js version used in production.

When debugging Event Loop behavior, check the runtime version:

Terminal — Check Node.js version
node --version

You can also check the libuv version from Node.js:

JavaScript — Runtime versions
console.log('Node.js:', process.version);
console.log('libuv:', process.versions.uv);

11. Common Node.js Event Loop Mistakes

Mistake 1: Using Synchronous File Operations in APIs

Using synchronous file-system APIs inside frequently executed request handlers can block the main JavaScript thread.

Better approach: Use asynchronous file-system APIs when appropriate.

Mistake 2: Assuming setTimeout(0) Runs Immediately

A zero-delay timer does not mean immediate execution. It means the callback becomes eligible after the timer threshold, subject to Event Loop scheduling.

Better approach: Do not use timers when you require an exact execution time.

Mistake 3: Creating Infinite nextTick Callbacks

Repeatedly scheduling next-tick callbacks can prevent the Event Loop from progressing to timers and I/O callbacks.

Better approach: Use controlled scheduling and break long-running work into manageable pieces.

Mistake 4: Running CPU-Heavy Calculations on the Main Thread

Large synchronous calculations can delay other callbacks and increase API latency.

Better approach: Consider Worker Threads, task queues, or separate worker processes depending on the workload.

Mistake 5: Assuming All Async Operations Use the Thread Pool

Some asynchronous operations use operating-system I/O mechanisms, while others use the libuv thread pool.

Better approach: Understand the implementation characteristics of the API you are using.

12. Monitoring Event Loop Performance

Understanding Event Loop behavior is useful, but production applications also need monitoring. Node.js provides the perf_hooks module, which includes tools for measuring Event Loop delay.

Example: Monitor Event Loop Delay

JavaScript — perf_hooks example
const {
  monitorEventLoopDelay
} = require('node:perf_hooks');

const histogram = monitorEventLoopDelay({
  resolution: 20
});

histogram.enable();

setInterval(() => {
  console.log({
    minMs: histogram.min / 1e6,
    maxMs: histogram.max / 1e6,
    meanMs: histogram.mean / 1e6,
    p99Ms: histogram.percentile(99) / 1e6
  });

  histogram.reset();
}, 5000);

This example measures Event Loop delay and reports statistics in milliseconds. The histogram values can help identify periods when the Event Loop is experiencing delays.

Production monitoring tip Monitor Event Loop delay together with API response time, CPU utilization, memory usage, error rates, and throughput. A single metric does not explain every performance problem.

13. Best Practices for Node.js Event Loop Performance

  • Prefer asynchronous I/O APIs for normal application workloads.
  • Avoid long-running synchronous JavaScript operations in request handlers.
  • Use Worker Threads for suitable CPU-intensive JavaScript tasks.
  • Use queueMicrotask() when direct microtask scheduling is appropriate.
  • Avoid excessive recursive process.nextTick() scheduling.
  • Do not depend on a fixed ordering between top-level setTimeout() and setImmediate().
  • Monitor Event Loop delay in production.
  • Test asynchronous execution behavior with your actual Node.js version and module format.
  • Use bounded worker pools and queues for resource-intensive tasks.
  • Profile before changing thread pool sizes or introducing concurrency.

14. Frequently Asked Questions

1. What is the Event Loop in Node.js?

The Event Loop is the mechanism that coordinates asynchronous callbacks and I/O events in Node.js. It allows the runtime to handle asynchronous operations without blocking JavaScript while those operations are pending.

2. Is Node.js single-threaded?

JavaScript execution in a typical Node.js application runs on a main thread. However, Node.js also uses operating-system facilities, libuv worker threads, and optional Worker Threads to support concurrent work.

3. What is the difference between microtasks and macrotasks?

Microtasks include Promise reactions and queueMicrotask() callbacks. Timer, I/O, and immediate callbacks are processed through Event Loop scheduling mechanisms. Node.js also maintains a separate next-tick queue.

4. Which executes first: process.nextTick() or Promise.then()?

In a typical CommonJS example, next-tick callbacks are processed before Promise microtasks at the relevant checkpoint. ES module evaluation can produce a different observed ordering, so always consider the module context.

5. What is the difference between setTimeout() and setImmediate()?

setTimeout() schedules a callback after a minimum delay, while setImmediate() schedules a callback for the Check phase. Their relative order can vary when both are scheduled from the top level.

6. Does every asynchronous operation use the libuv thread pool?

No. Some operations use the libuv thread pool, while network I/O is generally handled using operating-system asynchronous I/O facilities.

7. What is the default libuv thread pool size?

The default size is four worker threads. It can be configured using UV_THREADPOOL_SIZE before the Node.js process starts.

8. How can I prevent Event Loop blocking?

Avoid CPU-heavy synchronous work on the main thread, use asynchronous APIs, consider Worker Threads for CPU-intensive tasks, and monitor Event Loop delay.

9. What is the difference between Worker Threads and the libuv thread pool?

Worker Threads allow applications to run JavaScript in separate threads. The libuv thread pool is an internal runtime facility used by certain operations such as file-system, cryptographic, and compression work.

10. How can I measure Event Loop delay?

Use the monitorEventLoopDelay() function from Node.js's perf_hooks module to collect delay statistics such as minimum, maximum, mean, and percentile values.

15. Conclusion

The Node.js Event Loop is a core part of the runtime's asynchronous architecture. Understanding its phases and scheduling behavior helps developers build responsive and scalable backend applications.

The most important concepts to remember are:

  • The Event Loop coordinates asynchronous callback execution.
  • JavaScript on the main thread executes one callback at a time.
  • Node.js has a separate next-tick queue and a microtask queue.
  • Timers and immediate callbacks are processed in different Event Loop phases.
  • Some asynchronous operations use the libuv thread pool.
  • Worker Threads can help with CPU-intensive JavaScript workloads.
  • Monitoring Event Loop delay helps identify performance issues.

Once you understand these concepts, debugging asynchronous behavior and improving Node.js application performance becomes much easier.

Official References and Further Reading

Use these official documentation resources to explore the concepts in more detail:

Node.js — The Node.js Event Loop

Learn about Event Loop phases, timers, and next-tick scheduling.

Node.js — Timers API

Official documentation for setTimeout(), setInterval(), and setImmediate().

Node.js — process.nextTick()

Understand next-tick scheduling and its behavior.

Node.js — Worker Threads

Learn how to run JavaScript in separate threads.

Node.js — Performance Hooks

Explore performance measurement and Event Loop delay monitoring.

libuv — Design Overview

Understand the underlying Event Loop and asynchronous I/O design.

Article published by Programming Tech Lab — Practical programming tutorials for developers.

Comments