Worker threads stellen Node in staat JavaScript op afzonderlijke threads uit te voeren met echte parallelisme — waardoor Node's grootste beperking wordt opgelost: CPU-intensief werk blokkeert de enkele main thread (en dus alle requests). Gebruik ze voor zware berekeningen, niet voor I/O (wat de event loop al efficiënt afhandelt).
app.(, {
result = ();
res.(result);
});
Node voert uw JS op één thread uit. Een lange synchrone berekening blokkeert alles — de event loop kan andere requests niet verwerken totdat het klaar is. Worker threads verplaatsen dat werk van de main thread.
// main.js
import { Worker } from "worker_threads";
function runHeavyTask(data) {
return new Promise((resolve, reject) => {
const worker = new Worker("./worker.js", { workerData: data }); // runs on a NEW thread
worker.on("message", resolve); // receive the result
worker.on("error", reject);
worker.on("exit", (code) => { if (code !== 0) reject(new Error(`exit ${code}`)); });
});
}
// the main thread stays free to handle other requests while this runs
const result = await runHeavyTask({ numbers: [...] });
// worker.js — runs in parallel, on its own thread
import { workerData, parentPort } from "worker_threads";
const result = expensiveComputation(workerData); // doesn't block the main thread
parentPort.postMessage(result); // send the result back
De worker draait onafhankelijk; de main thread blijft requests bedienen en ontvangt het resultaat via een bericht wanneer het klaar is.
✓ USE for CPU-bound work: image/video processing, encryption, compression,
big data parsing, complex calculations, ML inference
✗ DON'T use for I/O (DB, files, HTTP) — the async event loop already handles
that efficiently; a worker would add overhead for no benefit
De regel: workers voor CPU-bound, event loop voor I/O-bound.
worker_threads → share memory (efficient data passing), in-process threads — CPU work
child_process → separate OS processes, run other programs — heavier isolation
cluster → fork the whole server across CPUs — scale request handling
Worker threads pakken Node's kernzwakte aan — CPU-bound taken blokkeren de single-threaded event loop en bevriezen alle gelijktijdige requests.
Weten hoe u zware berekeningen naar een worker kunt verplaatsen (de main thread responsief houdend), en vooral wanneer u ze gebruikt (alleen CPU-bound, nooit voor I/O), stelt een Node-service in staat occasioneel zware verwerking af te handelen zonder het gelijktijdigheid in te leveren dat Node waardevol maakt.
Voor het beheren van worker pools in productie beheren bibliotheken zoals Piscina een thread pool efficiënt.