Node.js worker threads for CPU-intensive tasks

CPU-intensive operations block the Node.js event loop, making the server unresponsive.

Use worker threads for CPU-bound work:

// worker.js
const { parentPort, workerData } = require('worker_threads');

function heavyComputation(data) {
  let result = 0;
  for (let i = 0; i < data.iterations; i++) {
    result += Math.sqrt(i) * Math.sin(i);
  }
  return result;
}

const result = heavyComputation(workerData);
parentPort.postMessage(result);

// main.js
const { Worker } = require('worker_threads');

function runWorker(data) {
  return new Promise((resolve, reject) => {
    const worker = new Worker('./worker.js', { workerData: data });
    worker.on('message', resolve);
    worker.on('error', reject);
    worker.on('exit', (code) => {
      if (code !== 0) reject(new Error(`Worker stopped with code ${code}`));
    });
  });
}

// Use in Express route
app.get('/compute', async (req, res) => {
  const result = await runWorker({ iterations: 1e8 });
  res.json({ result });
  // Event loop stays responsive during computation!
});

// Worker pool for reuse
const { StaticPool } = require('node-worker-threads-pool');

const pool = new StaticPool({
  size: 4,
  task: './worker.js',
});

app.get('/compute', async (req, res) => {
  const result = await pool.exec({ iterations: 1e8 });
  res.json({ result });
});

When to use worker threads vs child processes:

• Worker threads: Share memory (SharedArrayBuffer), lower overhead
• Child processes: Full isolation, can use different Node versions
• Neither: For I/O-bound work (use async/await instead)

Node.js is single-threaded. CPU work blocks the event loop, preventing I/O handling. Worker threads run in parallel threads while sharing the same process memory.

Node.js applications with CPU-intensive operations