What is 'starvation' in the context of the event loop? Give a real-world example.

Question

Accepted Answer

In the context of JavaScript's event loop, starvation occurs when a particular type of task is consistently unable to execute because the event loop is perpetually busy processing higher-priority tasks. Specifically, because the event loop processes all queued microtasks before moving on to the next macrotask, recursively adding microtasks can starve macrotasks (like `setTimeout`, I/O callbacks, and UI rendering). This is often referred to as a "microtask deadlock" or "microtask starvation". function starveEventLoop() {
  // This function recursively schedules itself as a microtask
  Promise.resolve().then(() => {
    console.log('Microtask running...');
    starveEventLoop(); // Adds another microtask
  });
}

starveEventLoop();

setTimeout(() => {
  // This will never run (or will run after a long time if the loop breaks)
  console.log('This setTimeout callback is starved!');
}, 0);

console.log('Synchronous code done');

// The microtasks will run infinitely, preventing the setTimeout callback from ever executing. **Promise-based while loop**: A common mistake is using a `Promise.resolve().then()` inside a loop to iterate without blocking the event loop. However, if the loop condition never becomes false, it will keep adding microtasks and starve I/O and timer events. **Unoptimized Virtual DOM Diffing**: A UI framework (like React) that uses microtasks for state updates could, in theory, cause starvation if an update triggers another update synchronously, leading to an infinite microtask cycle, though modern frameworks use heuristics to prevent this. **Recursive MutationObserver callbacks**: `MutationObserver` callbacks are microtasks. If a callback modifies the DOM in a way that triggers a new mutation, which then schedules another microtask, it can create a starvation loop, freezing the page. let count = 0;
const MAX_OPERATIONS = 1000;

function processLargeDataset(data) {
  if (count >= MAX_OPERATIONS) return;
  
  // Process a small chunk of data synchronously
  const chunk = data.slice(count, count + 10);
  console.log(`Processing chunk: ${chunk}`);
  count += 10;
  
  // Yield control to the event loop using setImmediate (macrotask)
  setImmediate(() => processLargeDataset(data));
}

// This will not starve the event loop; it will allow timers and I/O to interleave.
processLargeDataset(hugeArray);

setTimeout(() => {
  console.log('This timeout will execute between chunks');
}, 0); To prevent starvation, you must avoid recursively adding microtasks without yielding to the event loop. If you need to process a large amount of data without blocking, you can break the work into chunks and schedule the next chunk as a macrotask using `setTimeout(..., 0)` or `setImmediate()`. This ensures that the event loop has an opportunity to process other pending tasks, such as I/O operations and timers, preventing starvation.

What is 'starvation' in the context of the event loop? Give a real-world example.

Starvation in the event loop occurs when lower-priority tasks (like I/O callbacks or timers) are repeatedly delayed because higher-priority microtasks keep being added, preventing the event loop from ever processing the macrotask queue.

What is 'starvation' in the context of the event loop? Give a real-world example.

Starvation in the event loop occurs when lower-priority tasks (like I/O callbacks or timers) are repeatedly delayed because higher-priority microtasks keep being added, preventing the event loop from ever processing the macrotask queue.

Scenario Questions

Follow-up Questions