process.nextTick vs setImmediate in Node.js

While both process.nextTick() and setImmediate() are used to schedule asynchronous tasks in Node.js, their core difference lies in when their callbacks are executed within the Node.js event loop. process.nextTick() fires immediately after the current operation completes, before the event loop advances to the next phase. In contrast, setImmediate() places callbacks into the event loop’s Check phase, ensuring they run on the subsequent iteration after pending I/O events.

What is `process.nextTick()`?

process.nextTick() is technically not part of the event loop phases. Instead, it processes callbacks in the microtask queue (specifically the nextTickQueue).

When it runs: Callbacks queued by process.nextTick() are executed as soon as the current synchronous code finishes executing, right before Node.js returns to the event loop.
Risk of Starvation: Because it resolves before moving to any other event loop phase, recursively calling process.nextTick() can cause “I/O starvation,” completely blocking the event loop and preventing file system, network, or timer operations from executing.

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

What is `setImmediate()`?

setImmediate() is designed to execute code in the Check phase of the event loop.

When it runs: Callbacks are queued and executed after the Poll (I/O) phase of the event loop. This ensures that any pending I/O callbacks are processed before the setImmediate callback runs.
Non-blocking: Unlike process.nextTick(), setImmediate() yields execution back to the event loop, preventing I/O starvation.

setImmediate(() => {
  console.log("Executed in setImmediate");
});

Execution Order Example

Consider the following script:

const fs = require('fs');

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

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

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

Output:

process.nextTick
setImmediate
setTimeout

Explanation of Output: 1. Once the file read (I/O) completes, the callback runs. 2. process.nextTick() resolves immediately before transitioning to the next event loop phase. 3. The event loop transitions from the Poll phase directly into the Check phase, triggering setImmediate(). 4. setTimeout() executes in the Timers phase on the subsequent loop iteration.

Key Differences at a Glance

Feature	`process.nextTick()`	`setImmediate()`
Event Loop Phase	Microtask queue (runs before the next phase).	Check phase of the event loop.
Priority	Higher priority; runs before `setImmediate`.	Lower priority; queued within the loop.
Starvation Risk	High if called recursively.	Low; allows the loop to continue.
Primary Use Case	Cleaning up resources, handling errors before I/O, or ensuring APIs remain consistently asynchronous.	Executing non-blocking tasks after the current I/O cycle completes.

When to Use Which?

Use setImmediate() as the default choice for asynchronous scheduling. It is easier to reason about, safer for performance, and prevents unintended event loop blocking.
Use process.nextTick() sparingly, primarily when an API must allow users to register event handlers synchronously after an object is instantiated, or when an error needs to be thrown before any other I/O operations occur.