Clustering & Worker Threads

const cluster = require('node:cluster');
const os = require('node:os');
if (cluster.isPrimary) {
  for (let i = 0; i < os.cpus().length; i++) cluster.fork();
} else {
  require('./server');
}

Common follow-ups: How does the cluster module's shared-port mechanism distribute connections across workers?;What state can be shared between cluster workers, given they're separate OS processes?

// Broken with clustering: each worker has its own separate cache
const cache = new Map();

// Correct: external shared store
await redis.set(key, value);

Common follow-ups: What's the correct way to implement rate limiting correctly across cluster workers given this same issue?;How does this apply to WebSocket connections handled by a specific worker?

pm2 start server.js -i max --name my-app

// server.js needs zero cluster-specific code
const app = express();
app.listen(3000);

Common follow-ups: What does 'zero-downtime reload' mean operationally, and how does PM2 achieve it?;When would you still want the raw cluster module instead of PM2?

const sab = new SharedArrayBuffer(4);
const sharedArray = new Int32Array(sab);
Atomics.add(sharedArray, 0, 1);
console.log(Atomics.load(sharedArray, 0));

Common follow-ups: Why must operations on shared memory use Atomics rather than regular read/write?;What are the practical limits on data types inside a SharedArrayBuffer?

worker.postMessage({ command: 'process', data: [1, 2, 3] });

const buffer = new ArrayBuffer(1024 * 1024);
worker.postMessage({ buffer }, [buffer]); // transferred, zero-copy

Common follow-ups: What happens if you try to postMessage() a function or class instance with methods?;What's the performance difference between structured-clone copying and transferring an ArrayBuffer?

const pool = new Piscina({ filename: './cpu-task.js' });
app.post('/process', async (req, res) => {
  const result = await pool.run(req.body);
  res.json(result);
});

Common follow-ups: How do you size a worker pool relative to available CPU cores?;What happens to queued tasks if every worker is busy when a new request arrives?

const sticky = require('sticky-session');
if (!sticky.listen(server, 3000)) {
  server.once('listening', () => console.log('Server started'));
}

Common follow-ups: Why is sticky load balancing generally unnecessary if session state is already externalized to Redis?;How does sticky behavior interact with a cloud load balancer in front of the whole cluster?

pm2 reload my-app
// PM2 starts a new worker, waits for it to be ready, then gracefully
// shuts down one old worker at a time until all run the new code

Common follow-ups: What's the difference between 'pm2 restart' and 'pm2 reload' regarding downtime?;How long should a worker be given to drain requests before forced termination during a reload?

const numWorkers = process.env.WORKER_COUNT || os.cpus().length;
for (let i = 0; i < numWorkers; i++) cluster.fork();

Common follow-ups: How would you actually benchmark the optimal worker count for a real workload?;Does this intuition apply equally to worker threads used for CPU-bound tasks?

cluster.on('exit', (worker, code, signal) => {
  console.error(`Worker ${worker.process.pid} died. Forking a replacement.`);
  cluster.fork();
});

Common follow-ups: What's the risk of a worker crashing and restarting in a tight loop if a bug is triggered by every request of a certain type?;How would you add backoff or a circuit-breaker to the fork-on-exit logic?