Worker threads Node ਨੂੰ JavaScript ਨੂੰ ਵੱਖਰੇ threads 'ਤੇ ਚਲਾਉਣ ਦਿੰਦੇ ਹਨ ਸੱਚੀ parallelism ਦੇ ਨਾਲ — Node ਦੀ ਸਭ ਤੋਂ ਵੱਡੀ ਸੀਮਾ ਨੂੰ ਹੱਲ ਕਰਦੇ ਹਨ: CPU-intensive ਕੰਮ ਜੋ ਸਿੰਗਲ main thread ਨੂੰ ਬਲਾਕ ਕਰਦਾ ਹੈ (ਅਤੇ ਇਸ ਤਰ੍ਹਾਂ ਸਾਰੀਆਂ requests)। ਉਹਨਾਂ ਨੂੰ ਭਾਰੀ computation ਲਈ ਵਰਤੋ, I/O ਲਈ ਨਹੀਂ (ਜਿਸ ਨੂੰ event loop ਪਹਿਲਾਂ ਤੋਂ ਕੁਸ਼ਲਤਾ ਨਾਲ ਸੰਭਾਲਦਾ ਹੈ)।
app.(, {
result = ();
res.(result);
});
Node ਤੁਹਾਡੀ JS ਨੂੰ ਇੱਕ thread 'ਤੇ ਚਲਾਉਂਦਾ ਹੈ। ਇੱਕ ਲੰਬਾ synchronous computation ਸਭ ਕੁਝ ਬਲਾਕ ਕਰਦਾ ਹੈ — 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
ਨਿਯਮ: CPU-bound ਲਈ workers, I/O-bound ਲਈ event loop।
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 ਕਾਮਾਂ ਜੋ single-threaded event loop ਨੂੰ ਬਲਾਕ ਕਰਦੇ ਹਨ ਅਤੇ ਸਾਰੀਆਂ concurrent requests ਨੂੰ freeze ਕਰ ਦਿੰਦੇ ਹਨ।
ਜਾਣਨਾ ਕਿ ਭਾਰੀ computation ਨੂੰ ਇੱਕ worker ਨੂੰ offload ਕਿਵੇਂ ਕਰਨਾ ਹੈ (main thread ਨੂੰ responsive ਰੱਖਦੇ ਹੋਏ), ਅਤੇ ਜ਼ਰੂਰੀ ਤੌਰ 'ਤੇ ਕਦੋਂ ਉਹਨਾਂ ਨੂੰ ਵਰਤਣਾ ਹੈ (ਸਿਰਫ CPU-bound, I/O ਲਈ ਕਦੇ ਨਹੀਂ), ਉਹ ਹੈ ਜੋ ਇੱਕ Node service ਨੂੰ ਅਨੌਖੀ ਭਾਰੀ processing ਨੂੰ ਸੰਭਾਲਣ ਦਿੰਦਾ ਹੈ ਬਿਨਾ concurrency ਨੂੰ ਕੁਰਬਾਨ ਦਿੱਤੇ ਜੋ Node ਨੂੰ ਮੁੱਲਵਾਨ ਬਣਾਉਂਦੀ ਹੈ।
Production ਵਿੱਚ workers ਨੂੰ ਪੂਲ ਕਰਨ ਲਈ, Piscina ਵਰਗੀਆਂ libraries ਇੱਕ thread pool ਨੂੰ ਕੁਸ਼ਲਤਾ ਨਾਲ ਪ੍ਰਬੰਧਿਤ ਕਰਦੀਆਂ ਹਨ।