Node.js event loop deep dive

import { monitorEventLoopDelay } from 'perf_hooks';
import { AsyncLocalStorage } from 'async_hooks';

const loopMonitor = monitorEventLoopDelay({ resolution: 10 });
loopMonitor.enable();

export const eventLoopLag = () => {
  const stats = loopMonitor.histogram;
  return {
    mean: stats.mean,
    p95: stats.percentile(95),
    p99: stats.percentile(99),
    count: stats.count,
  };
};

export const asyncContext = new AsyncLocalStorage<string>();

import { Worker, isMainThread, parentPort, workerData } from 'worker_threads';
import { cpus } from 'os';

const WORKER_COUNT = Math.max(1, cpus().length - 1);
const workerPool: Worker[] = [];

if (isMainThread) {
  for (let i = 0; i < WORKER_COUNT; i++) {
    workerP

ool.push(new Worker(__filename)); } }

export const runCpuTask = <T>(data: unknown): Promise<T> => { const worker = workerPool[Math.floor(Math.random() * workerPool.length)]; return new Promise((resolve, reject) => { worker.once('message', resolve); worker.once('error', reject); worker.postMessage(data); }); };

if (!isMainThread) { parentPort?.on('message', async (task) => { const result = await executeCpuHeavyOperation(task); parentPort?.postMessage(result); }); }

### Step 3: Tune libuv and Balance Scheduling
Increase the libuv thread pool for I/O-heavy workloads. Avoid recursive `process.nextTick`. Use `setImmediate` for deferring non-critical work to the check phase.

```typescript
import { UV_THREADPOOL_SIZE } from 'process';

// Set before any async operations
process.env.UV_THREADPOOL_SIZE = String(Math.max(4, cpus().length * 2));

// Correct deferral pattern
export const deferToCheckPhase = (fn: () => void) => {
  setImmediate(fn); // Runs after poll phase, prevents microtask starvation
};

// Chunked synchronous processing
export const processInChunks = async <T>(
  items: T[],
  chunkSize: number,
  processor: (chunk: T[]) => void
) => {
  for (let i = 0; i < items.length; i += chunkSize) {
    const chunk = items.slice(i, i + chunkSize);
    processor(chunk);
    await new Promise(setImmediate); // Yield to event loop between chunks
  }
};

Architecture Rationale: The event loop is a single-threaded cooperative scheduler. Blocking it violates the concurrency model. Worker threads isolate CPU work, perf_hooks provides deterministic lag measurement, and chunking with setImmediate yields control back to the poll phase. This architecture decouples I/O scheduling from computation, maintaining predictable latency under load.

Pitfall Guide

1. Synchronous crypto/hash operations in hot paths crypto.createHash('sha256').update(largeBuffer).digest() blocks the main thread. libuv’s thread pool handles async crypto, but the sync API runs inline. Offload to workers or use crypto.hash() with async streaming.

2. Microtask starvation via recursive process.nextTick nextTick queue drains before the event loop advances. Recursive calls prevent poll, check, and close phases from executing. Use setImmediate or setTimeout(fn, 0) for deferred work.

3. Assuming setImmediate runs before setTimeout Execution order depends on loop phase entry. setTimeout runs in timers phase; setImmediate runs in check phase. If the loop enters directly at check, setImmediate fires first. Never rely on relative ordering between them.

4. Ignoring libuv thread pool exhaustion Default size is 4. Concurrent DNS, TLS, or fs operations serialize beyond this limit. Set UV_THREADPOOL_SIZE based on I/O concurrency requirements, not CPU cores.

5. Blocking the poll phase with JSON parsing JSON.parse() on payloads >500KB blocks the main thread. Use streaming parsers (JSONStream, stream-json) or chunked deserialization with async yielding.

6. Over-relying on async/await without chunking await yields to the microtask queue, not the event loop. A large synchronous loop wrapped in async still blocks. Insert await new Promise(setImmediate) every N iterations.

7. Misusing Promise resolution order expectations Promises resolve in the microtask queue after the current operation. Multiple Promise.resolve() calls in the same tick execute sequentially before the loop continues. Do not assume parallelism.

Best Practices from Production:

• Measure loop lag continuously; alert on p99 > 20ms.
• Isolate CPU work to workers; never run in request handlers.
• Stream large payloads; never parse monolithically.
• Use setImmediate for deferral; reserve nextTick for library-level API consistency.
• Tune UV_THREADPOOL_SIZE per service I/O profile.

Production Bundle

Action Checklist

• Instrument event loop lag using perf_hooks.monitorEventLoopDelay
• Offload CPU-bound operations to worker_threads
• Replace synchronous JSON/crypto/fs with async or streaming alternatives
• Set UV_THREADPOOL_SIZE based on concurrent I/O requirements
• Replace recursive process.nextTick with setImmediate or chunked async patterns
• Implement request payload size limits and streaming parsers
• Add p99 latency and loop lag metrics to observability dashboards
• Load test with concurrent connections to verify poll phase responsiveness

Decision Matrix

Scenario	Recommended Approach	Why	Cost Impact
CPU-bound data transformation	Worker Threads	Isolates computation, zero-copy via SharedArrayBuffer	+15% memory, +0% latency
High-concurrency I/O (DNS, TLS, fs)	Increase UV_THREADPOOL_SIZE	Prevents libuv queue serialization	+5% RAM, -40% I/O wait
Large JSON payload processing	Streaming parser + chunked async	Avoids main thread blocking during parse	+10% code complexity, -60% p99 lag
Deferred non-critical work	setImmediate	Runs in check phase, prevents microtask starvation	Neutral
Recursive async iteration	Chunked processing + await new Promise(setImmediate)	Yields to event loop, maintains responsiveness	+5% execution time, -90% loop block

Configuration Template

// event-loop.config.ts
import { cpus } from 'os';
import { monitorEventLoopDelay } from 'perf_hooks';

export const EVENT_LOOP_CONFIG = {
  threadPoolSize: Math.max(4, cpus().length * 2),
  workerCount: Math.max(1, cpus().length - 1),
  lagThresholdMs: 20,
  chunkSize: 1000,
  enableMonitoring: true,
};

export const initEventLoopMonitoring = () => {
  if (!EVENT_LOOP_CONFIG.enableMonitoring) return;
  
  const monitor = monitorEventLoopDelay({ resolution: 10 });
  monitor.enable();
  
  setInterval(() => {
    const stats = monitor.histogram;
    if (stats.percentile(99) > EVENT_LOOP_CONFIG.lagThresholdMs) {
      console.warn(
        `[EVENT_LOOP] p99 lag ${stats.percentile(99).toFixed(2)}ms exceeds threshold`
      );
    }
  }, 5000);
};

export const configureLibuv = () => {
  process.env.UV_THREADPOOL_SIZE = String(EVENT_LOOP_CONFIG.threadPoolSize);
};

Quick Start Guide

1. Initialize monitoring: Add initEventLoopMonitoring() to your application entry point before any route registration.
2. Configure thread pool: Call configureLibuv() at the top of your main file to set UV_THREADPOOL_SIZE.
3. Create a worker module: Save CPU-intensive logic in a separate file, use isMainThread guards, and export a runCpuTask wrapper.
4. Replace sync hot paths: Identify synchronous operations in request handlers, wrap them in chunked async patterns or delegate to the worker pool.
5. Validate under load: Run a load test (e.g., autocannon -c 1000 -d 60 http://localhost:3000) and verify p99 event loop lag stays below 20ms.