Event loop phases and timer execution in Node.js - Performance & Optimization

Performance: Event loop phases and timer execution

MEDIUM IMPACT

This concept affects how quickly Node.js processes timers and callbacks, impacting responsiveness and throughput of server-side applications.

Scheduling repeated tasks with timers

Node.js

function heavyTask() {
  return new Promise(resolve => {
    setImmediate(() => {
      for(let i = 0; i < 1e8; i++) {}
      resolve();
    });
  });
}

async function runInterval() {
  while(true) {
    await heavyTask();
    console.log('Interval task done');
    await new Promise(r => setTimeout(r, 1000));
  }
}

runInterval();

Offloads heavy work to next event loop phase and uses async delays to avoid blocking timers.

📈 Performance GainKeeps event loop responsive, timers fire on time, and other callbacks run smoothly.

Scheduling repeated tasks with timers

Node.js

setInterval(() => {
  // heavy synchronous task
  for(let i = 0; i < 1e8; i++) {}
  console.log('Interval task done');
}, 1000);

Heavy synchronous work inside setInterval blocks the event loop, delaying other callbacks and timers.

📉 Performance CostBlocks event loop for hundreds of milliseconds each interval, causing delayed timer execution.

Performance Comparison

Pattern	Event Loop Blocking	Timer Accuracy	CPU Usage	Verdict
Heavy synchronous code in setInterval	Blocks event loop for 100+ ms	Timers delayed	High CPU spikes	[X] Bad
Async heavy task with setImmediate and await	No blocking, event loop free	Timers fire on time	Balanced CPU usage	[OK] Good

Rendering Pipeline

Node.js event loop cycles through phases: timers, pending callbacks, idle/prepare, poll, check, and close callbacks. Timer callbacks run in the timers phase if their scheduled time has elapsed.

→Timers phase

→Poll phase

→Check phase

⚠️ BottleneckBlocking synchronous code in any phase delays subsequent phases and timer execution.

Optimization Tips

1Avoid heavy synchronous code inside timer callbacks to prevent event loop blocking.

2Timer callbacks run in the timers phase only after their scheduled delay has passed.

3Use asynchronous patterns to keep the event loop free and timers firing on time.

Performance Quiz - 3 Questions

What happens if a timer callback contains heavy synchronous code?

A It runs in parallel without blocking.

B It speeds up timer execution.

C It blocks the event loop, delaying other timers and callbacks.

D It causes the event loop to skip phases.

DevTools: Performance

How to check: Record a CPU profile while running your Node.js app with timers. Look for long tasks blocking the event loop and delayed timer callbacks.

What to look for: Long blocking tasks in the flame chart and timer callbacks not firing at expected intervals indicate poor timer handling.

Practice

1. Which phase of the Node.js event loop executes setTimeout callbacks?

easy

A. Check phase

B. Timers phase

C. Poll phase

D. Close callbacks phase

Solution

1. Step 1: Understand event loop phases

   The Node.js event loop has multiple phases, each handling different types of callbacks.

2. Step 2: Identify where timers run

   The timers phase is specifically designed to execute callbacks scheduled by setTimeout and setInterval.

3. Final Answer:

   Timers phase -> Option B

4. Quick Check:

   Timers phase = setTimeout callbacks [OK]

Hint: Timers run in the timers phase, not immediately [OK]

Common Mistakes:

• Confusing timers phase with poll phase
• Thinking setTimeout runs immediately
• Mixing check phase with timers phase

2. Which of the following is the correct syntax to schedule a function to run after 0 milliseconds in Node.js?

easy

A. setTimeout(console.log('Hi'))

B. setTimeout(console.log('Hi'), 0);

C. setTimeout(0, () => console.log('Hi'));

D. setTimeout(() => console.log('Hi'), 0);

Solution

1. Step 1: Check function syntax for setTimeout

   The first argument must be a function, not the result of a function call.

2. Step 2: Analyze each option

   setTimeout(() => console.log('Hi'), 0); passes a function that logs 'Hi' after 0 ms delay correctly. setTimeout(console.log('Hi'), 0); calls console.log immediately and passes its result (undefined). setTimeout(0, () => console.log('Hi')); passes 0 (number) as first argument instead of a function, causing a TypeError on execution. setTimeout(console.log('Hi')) calls console.log immediately without delay argument.

3. Final Answer:

   setTimeout(() => console.log('Hi'), 0); -> Option D

4. Quick Check:

   Function as first argument = setTimeout(() => console.log('Hi'), 0); [OK]

Hint: Pass a function, not a function call, to setTimeout [OK]

Common Mistakes:

• Calling the function immediately inside setTimeout
• Omitting the delay argument
• Passing non-function as first argument

3. What will be the output order of the following code?

console.log('Start');
setTimeout(() => console.log('Timeout 1'), 0);
setTimeout(() => console.log('Timeout 2'), 10);
console.log('End');

medium

A. Start, End, Timeout 1, Timeout 2

B. Start, Timeout 1, Timeout 2, End

C. Timeout 1, Timeout 2, Start, End

D. Start, Timeout 2, End, Timeout 1

Solution

1. Step 1: Identify synchronous and asynchronous parts

   console.log('Start') and console.log('End') run immediately in order. setTimeout callbacks run later.

2. Step 2: Understand timer delays and event loop

   setTimeout with 0 ms delay runs after current code finishes, before 10 ms delay callback.

3. Final Answer:

   Start, End, Timeout 1, Timeout 2 -> Option A

4. Quick Check:

   Synchronous logs first, then timers by delay [OK]

Hint: Synchronous logs run before any setTimeout callbacks [OK]

Common Mistakes:

• Assuming 0 ms timeout runs immediately
• Mixing order of synchronous and asynchronous logs
• Ignoring timer delays

4. Identify the error in this code snippet:

setTimeout(console.log('Hello'), 1000);

medium

A. The delay argument is missing

B. The delay must be 0 or less

C. console.log is called immediately instead of after 1000ms

D. setTimeout requires a string as first argument

Solution

1. Step 1: Analyze the first argument of setTimeout

   console.log('Hello') is called immediately, returning undefined, which is passed to setTimeout.

2. Step 2: Understand correct usage

   setTimeout expects a function as first argument, not the result of a function call.

3. Final Answer:

   console.log is called immediately instead of after 1000ms -> Option C

4. Quick Check:

   Function call inside setTimeout runs immediately [OK]

Hint: Pass a function, not a function call, to setTimeout [OK]

Common Mistakes:

• Thinking delay argument is missing
• Passing string instead of function
• Believing delay must be zero or negative

5. Consider this code:

console.log('A');
setTimeout(() => console.log('B'), 0);
Promise.resolve().then(() => console.log('C'));
console.log('D');

What is the correct order of output?

hard

A. A, D, C, B

B. A, B, D, C

C. A, D, B, C

D. A, C, D, B

Solution

1. Step 1: Identify synchronous, microtask, and timers

   console.log('A') and console.log('D') run immediately. Promise.then callbacks run in microtasks after current code. setTimeout callbacks run in timers phase later.

2. Step 2: Determine execution order

   Output order is synchronous logs first (A, D), then microtasks (C), then timers (B).

3. Final Answer:

   A, D, C, B -> Option A

4. Quick Check:

   Microtasks run before timers [OK]

Hint: Promise.then runs before setTimeout even with 0 delay [OK]

Common Mistakes:

• Assuming setTimeout runs before Promise.then
• Mixing synchronous and asynchronous order
• Ignoring microtask queue priority