Node.js Worker Threads

Node.js Worker Threads: Parallel CPU-Bound Computation & Shared Memory

The node:worker_threads module enables true parallel execution of CPU-heavy tasks (such as image manipulation, matrix calculations, or cryptography) on separate threads without blocking the main event loop thread.

Worker Threads Architecture & Thread Communication

flowchart LR
    A["Main Thread (Event Loop)"] -->|"Worker Thread Spawning"| B["Worker Thread Instance"]
    A -->|"parentPort.postMessage(data)"| B
    B -->|"parentPort.postMessage(result)"| A
    A <-->|"SharedArrayBuffer"| B

Practical Code Example

// worker_app.js - Main Thread & Worker logic combined via isMainThread
import { Worker, isMainThread, parentPort, workerData } from 'node:worker_threads';
import { fileURLToPath } from 'node:url';

const __filename = fileURLToPath(import.meta.url);

if (isMainThread) {
    console.log(`[Main Thread PID ${process.pid}] Dispatching heavy CPU computation task...`);

    const worker = new Worker(__filename, {
        workerData: { iterations: 1_000_000_000 }
    });

    worker.on('message', (result) => {
        console.log(`[Main Thread] Calculation complete! Sum: ${result.totalSum}`);
    });

    worker.on('error', (err) => console.error('[Worker Error]:', err));
    worker.on('exit', (code) => console.log(`Worker exited with code ${code}`));
} else {
    // Inside Worker Thread Execution Context
    const { iterations } = workerData;
    let sum = 0;

    for (let i = 0; i < iterations; i++) {
        sum += i;
    }

    // Send result back to Main Thread
    parentPort.postMessage({ totalSum: sum });
}

Best Practices & Gotchas

• Do Not Use Workers for I/O Operations: Node.js default asynchronous I/O is already non-blocking; use Worker Threads only for CPU-bound tasks.
• Use Thread Pools: Spawning threads incurs overhead; use worker thread pools (such as piscina) for recurring tasks.
• Use SharedArrayBuffer for Large Data Transfers: Transferring large payloads serializes data; use SharedArrayBuffer or ArrayBuffer transfer lists for zero-copy memory transfers.

Self-Check Challenge

How does data sharing differ between child_process.fork() and worker_threads?