All 15 Clustering & Worker Threads questions
More in Clustering & Worker Threads
How do you pass data between the main thread and a worker thread using postMessage(), and what are the limits on what can be sent? What is the difference between the 'sticky' and default load-balancing strategies when using Node's cluster module, and when does it matter? What is the difference between the number of CPU cores and the optimal number of cluster workers for a given Node.js application? What is the difference between spawning a Worker Thread and spawning a Child Process for running a CPU-intensive JavaScript function? What happens to in-memory state (like an in-memory cache) when using the Node.js cluster module, and how do you handle this correctly? How do you use SharedArrayBuffer to share memory directly between Node.js worker threads, and what are the safety considerations? What is a worker thread pool, and why would you build one rather than creating a new Worker for every task? How does zero-downtime restart work with Node's cluster module or PM2, and why is it important for production deployments? How do you handle an uncaught exception inside a specific cluster worker without taking down the entire application? What is the WorkerData option when creating a Worker, and how does it differ from communicating via postMessage() after creation?
Advertisement
Node.js › Clustering & Worker Threads

How do you gracefully terminate a worker thread, and what's the difference between worker.terminate() and letting it exit naturally?

Intermediate

Answer

worker.terminate() forcibly and immediately stops execution regardless of current work, abandoning in-progress work -- appropriate for canceling unneeded tasks. Letting a worker exit naturally allows pending operations to complete first, providing a cleaner shutdown when its own work is genuinely finished.
setTimeout(() => worker.terminate(), 30000); // cancel if it takes too long
worker.on('exit', (code) => console.log(`Worker exited with code ${code}`));
Real-world example A request-timeout mechanism calls worker.terminate() on a task running over 30 seconds, ensuring a stuck task doesn't tie up pool capacity indefinitely, at the cost of losing partial progress.

Common follow-ups: What cleanup responsibilities does code inside a worker have before being forcibly terminated?;How would you implement graceful cancellation where the worker checks a flag periodically rather than being killed?

Error Handling;Performance Optimization & Profiling
All 15 Clustering & Worker Threads questions