All 15 Event Loop & Non-blocking IO questions
More in Event Loop & Non-blocking IO
How does the event loop handle a large synchronous loop (like processing a huge array with a for loop), and what problem does this cause? What does it mean that Node.js's I/O is handled by libuv, and how does libuv abstract different operating systems' I/O mechanisms? What is the difference between synchronous and asynchronous versions of the same core Node.js API, using fs.readFile vs fs.readFileSync as an example, and when is the synchronous version actually appropriate? How would you measure how 'busy' the event loop is in a running Node.js process using a simple technique? What is 'event loop lag' (or 'event loop delay'), and how would you monitor it in a production Node.js application? What is the poll phase of the event loop, and under what specific conditions does it block waiting versus move on immediately? What is the difference between how Node.js handles I/O-bound concurrency versus CPU-bound work, and why does this distinction shape Node.js's ideal use cases? How would you use async_hooks (the lower-level predecessor to AsyncLocalStorage) to trace the lifecycle of asynchronous resources in Node.js? How does the V8 JavaScript engine's microtask queue interact with the Node.js event loop's macrotask phases, and why does this occasionally surprise developers?
Advertisement
Back to results for “Debugging”
Node.js › Event Loop & Non-blocking IO

What are the distinct phases of the Node.js event loop, and what kind of callbacks does each phase execute?

Advanced

Answer

The event loop cycles through several phases each iteration: timers (executes callbacks scheduled by setTimeout/setInterval whose time has elapsed), pending callbacks (certain system-level callbacks deferred from the previous cycle), poll (retrieves new I/O events and executes their callbacks, and is where the loop will block waiting for new events if there's nothing else to do), check (executes setImmediate() callbacks), and close callbacks (handles cleanup for closed connections/handles) -- with microtasks (process.nextTick and Promise callbacks) draining completely between each of these phases.
setTimeout(() => console.log('timers phase'), 0);
setImmediate(() => console.log('check phase'));

fs.readFile(__filename, () => {
  setTimeout(() => console.log('timer from within poll'), 0);
  setImmediate(() => console.log('immediate from within poll')); // guaranteed to run first here
});
Real-world example A developer debugging unexpected ordering between a setTimeout(fn, 0) and a setImmediate() callback learns that their relative order at the top level of a script isn't strictly guaranteed, but inside an I/O callback (within the poll phase), setImmediate() is always guaranteed to fire before a zero-delay setTimeout, since the check phase directly follows poll.

Common follow-ups: Why is the ordering between setTimeout(fn, 0) and setImmediate() considered non-deterministic at the top level of a script but deterministic inside an I/O callback?;What specifically happens during the poll phase when there's no pending I/O and no timers scheduled?

Advanced Node.js;Debugging & Diagnostics
All 15 Event Loop & Non-blocking IO questions