Worker pool pattern in Node.js - Performance & Optimization

Performance: Worker pool pattern

HIGH IMPACT

This pattern affects how efficiently CPU-intensive tasks are handled without blocking the main event loop, improving responsiveness and throughput.

Handling multiple CPU-heavy tasks in a Node.js server

Node.js

const http = require('http');
const { Worker } = require('worker_threads');

function runHeavyTask() {
  return new Promise((resolve, reject) => {
    const worker = new Worker('./heavyTask.js');
    worker.on('message', resolve);
    worker.on('error', reject);
  });
}

http.createServer(async (req, res) => {
  const result = await runHeavyTask();
  res.end(`Result: ${result}`);
}).listen(3000);

Heavy tasks run in worker threads, freeing the main thread to handle other requests and inputs smoothly.

📈 Performance GainMain thread remains responsive; INP improves significantly; throughput increases under load.

Handling multiple CPU-heavy tasks in a Node.js server

Node.js

const http = require('http');
http.createServer((req, res) => {
  // Heavy computation directly on main thread
  let result = 0;
  for (let i = 0; i < 1e9; i++) {
    result += i;
  }
  res.end(`Result: ${result}`);
}).listen(3000);

Heavy computation blocks the main event loop, causing slow response times and poor input responsiveness.

📉 Performance CostBlocks main thread for hundreds of milliseconds per request, causing high INP and poor user experience.

Performance Comparison

Pattern	CPU Usage	Memory Usage	Main Thread Blocking	Verdict
Heavy tasks on main thread	High CPU on main thread	Low memory	Blocks main thread causing high INP	[X] Bad
Unlimited workers for each task	High CPU across many threads	High memory usage	Less main thread blocking but high overhead	[!] OK
Worker pool with limited threads	Balanced CPU across workers	Controlled memory usage	No main thread blocking, smooth responsiveness	[OK] Good

Rendering Pipeline

In Node.js, the worker pool pattern moves CPU-intensive tasks off the main event loop thread to worker threads, preventing blocking. This keeps the event loop free to handle I/O and user interactions smoothly.

→Event Loop

→Thread Pool

→Task Scheduling

⚠️ BottleneckMain thread blocking due to synchronous heavy computation

Core Web Vital Affected

INP

This pattern affects how efficiently CPU-intensive tasks are handled without blocking the main event loop, improving responsiveness and throughput.

Optimization Tips

1Offload CPU-heavy tasks to worker threads to keep the main event loop free.

2Limit the number of worker threads with a pool to avoid resource exhaustion.

3Reuse workers to reduce thread creation overhead and improve throughput.

Performance Quiz - 3 Questions

What is the main performance benefit of using a worker pool in Node.js?

A It decreases memory usage by avoiding caching.

B It prevents blocking the main event loop by offloading heavy tasks.

C It reduces network latency for HTTP requests.

D It speeds up database queries automatically.

DevTools: Performance

How to check: Record a CPU profile while running heavy tasks. Look for long main thread tasks and thread activity.

What to look for: Long blocking tasks on main thread indicate poor pattern; balanced CPU usage across worker threads and short main thread tasks indicate good pattern.