Worker threads საშუალებას აძლევს Node-ს JavaScript-ის გაშვება ცალკეულ threads-ებზე ჭეშმარიტი parallelism-ით — ხსნის Node-ის უდიდესი შეზღუდვა: CPU-ინტენსიური სამუშაო ბლოკავს ერთ main thread-ს (და ამით ყველა requests-ს). გამოიყენეთ მძიმე გამოთვლებისთვის, არა I/O-სთვის (რომელსაც event loop უკვე ეფექტურად ამუშავებს).
app.(, {
result = ();
res.(result);
});
Node გაშვებულია თქვენი JS ერთ thread-ზე. გრძელი სინქრონული გამოთვლა ბლოკავს ყველაფერს — event loop ვერ დამუშავდება სხვა requests-ებს, სანამ დასრულდება. Worker threads გადააქვთ ეს სამუშაო 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
Worker დამოუკიდებლად მუშაობს; main thread განაგრძობს requests-ების მომსახურებას და პასუხს მიიღებს message-ის მাშინ როცა დასრულდება.
✓ 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
წესი: workers CPU-bound-ისთვის, event loop 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 მოაგვარებს Node-ის ძირითად სუსტყოს — CPU-bound ამოცანები ბლოკავს ერთ-thread-ის event loop-ს და აყინებს ყველა ერთდროული requests-ს.
მნიშვნელოვანია იცოდეთ, რომ მძიმე გამოთვლა გადაიტანოთ worker-ზე (რათა main thread რეაქტიული დარჩეს), და კრიტიკულად როდის გამოიყენოთ (მხოლოდ CPU-bound, არასოდეს I/O-სთვის), ეს არის ის, რაც საშუალებას აძლევს Node service-ს დაამუშაოს ზოგჯერ მძიმე დამუშავება ტალღის გარეშე, რომელიც Node-ს ფასდაფასებული ხდის.
წარმოების მასშტაბზე workers-ის pooling-ის ჯამურობისთვის, Piscina-სთან მსგავსი ბიბლიოთეკები thread pool-ს ეფექტურად მართავენ.