Worker threads pozwalają Node uruchamiać JavaScript na oddzielnych wątkach z prawdziwym paralelizmem — rozwiązując największe ograniczenie Node'a: CPU-intensive prace blokujące pojedynczy główny wątek (i tym samym wszystkie żądania). Używaj ich do ciężkich obliczeń, a nie dla I/O (które event loop już efektywnie obsługuje).
app.(, {
result = ();
res.(result);
});
Node uruchamia Twój JS na jednym wątku. Długie obliczenia synchroniczne blokują wszystko — event loop nie może przetwarzać innych żądań, dopóki się nie skończą. Worker threads przenoszą tę pracę z głównego wątku.
// 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
Worker działa niezależnie; główny wątek nadal obsługuje żądania i otrzymuje wynik za pośrednictwem wiadomości po zakończeniu.
✓ 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
Reguła: worker threads dla CPU-bound, event loop dla 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 rozwiązują podstawową słabość Node — CPU-bound zadania blokujące jednowątkowy event loop i zamraża wszystkie współbieżne żądania.
Wiedza, jak offloadować ciężkie obliczenia do workera (utrzymując główny wątek responsywny) i krytycznie kiedy ich używać (tylko CPU-bound, nigdy dla I/O), to to, co pozwala usłudze Node obsługiwać okazjonalne ciężkie przetwarzanie bez poświęcania współbieżności, która czyni Node wartościowym.
Do łączenia workerów w produkcji biblioteki takie jak Piscina efektywnie zarządzają pulą wątków.