Feldolgozó szálak lehetővé teszik a Node számára, hogy JavaScriptet külön szálakon futtasson valódi párhuzamossággal — megoldva a Node legnagyobb korlátját: a CPU-igényes munkát, amely blokkolja az egyetlen fő szálat (és így az összes kérést). Használd őket nehéz számításokhoz, nem I/O-hoz (amit az event loop már hatékonyan kezel).
app.(, {
result = ();
res.(result);
});
A Node egy szálon futtatja a JS-ed. A hosszú szinkron számítás mindent blokk — az event loop nem tud más kéréseket feldolgozni, amíg az be nem fejeződik. A feldolgozó szálak ezt a munkát a fő szálról viszik el.
// 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
A feldolgozó önállóan fut; a fő szál továbbra is kiszolgálja a kéréseket, és egy üzenet által kapja meg az eredményt, amikor kész.
✓ 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
A szabály: feldolgozók a CPU-kötöttekhez, event loop az I/O-kötöttekhez.
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
A feldolgozó szálak a Node alapvető gyengeségét kezelik — a CPU-kötött feladatok blokkolják az egyszálú event loopot, és minden párhuzamos kérést befagyasztanak.
Annak ismerete, hogy a nehéz számításokat feldolgozóra kell áthelyezni (a fő szálat érzékenyül tartva), és kritikusan mikor kell őket használni (csak CPU-kötött, sosem I/O-hoz), az, ami lehetővé teszi egy Node szolgáltatásnak, hogy időnként nehéz feldolgozást kezeljen anélkül, hogy feláldozná azt a párhuzamosságot, amely a Node-ot értékessé teszi.
Az éles üzemelésben feldolgozók készlethez olyan könyvtárak, mint a Piscina hatékonyan kezelik a szálkészletet.