When to use workers vs cluster in Node.js - Practice Questions

Challenge - 5 Problems

🧠 Conceptual

intermediate

Understanding the main difference between workers and cluster in Node.js

Which statement best describes the primary difference between Node.js workers and cluster modules?

A Cluster runs code in multiple threads sharing the same event loop, workers create separate processes.

B Workers run in separate threads sharing memory, while cluster creates separate processes with independent memory.

C Workers and cluster both create separate processes but cluster shares memory between them.

D Cluster uses threads inside a single process, workers spawn multiple processes.

💡 Hint

Think about how memory is shared or isolated between threads and processes.

Workers run in separate threads within the same process and can share memory using SharedArrayBuffer. Cluster creates separate Node.js processes, each with its own memory space.

❓ component_behavior

intermediate

Choosing between workers and cluster for CPU-intensive tasks

You want to perform CPU-heavy calculations without blocking the main Node.js event loop. Which approach is best?

A Use cluster to spawn multiple processes, each handling a part of the calculation.

B Use cluster to run calculations in threads sharing memory to reduce overhead.

C Use a single process with asynchronous callbacks to handle calculations.

D Use workers to run calculations in separate threads without blocking the main thread.

💡 Hint

Consider which method allows parallel execution without blocking the main event loop.

Workers run in separate threads allowing CPU-intensive tasks to run in parallel without blocking the main event loop. Cluster creates separate processes but does not share memory, which can add overhead.

🔧 Debug

advanced

Debugging memory usage with cluster vs workers

You notice high memory usage in your Node.js app using cluster. Which cause is most likely?

Node.js

const cluster = require('cluster');
const http = require('http');

if (cluster.isMaster) {
  for (let i = 0; i < 4; i++) {
    cluster.fork();
  }
} else {
  http.createServer((req, res) => {
    res.end('Hello World');
  }).listen(8000);
}

A Each cluster worker is a separate process with its own memory, increasing total memory use.

B Cluster workers share memory, so memory usage should be low and shared.

C Cluster uses threads that share memory, causing memory leaks if not handled.

D Cluster automatically frees memory after each request, so memory usage is unrelated.

💡 Hint

Think about how processes handle memory separately.

Each cluster worker runs as a separate process with its own memory space, so total memory usage is the sum of all workers' memory. This can cause high memory use compared to threads.

📝 Syntax

advanced

Correct syntax to create a worker thread in Node.js

Which code snippet correctly creates a worker thread in Node.js?

A

const { Worker } = require('worker_threads');
const worker = new Worker('./worker.js');

B

const cluster = require('cluster');
const worker = cluster.fork('./worker.js');

C

const { Worker } = require('worker_threads');
const worker = Worker('./worker.js');

D const worker = new WorkerThreads('./worker.js');

💡 Hint

Check the correct import and constructor usage for worker threads.

The Worker class is imported from 'worker_threads' and instantiated with the new keyword and the path to the worker script.

❓ state_output

expert

Output behavior when using cluster with shared server port

Given the following code, what will be the output when multiple cluster workers listen on the same port?

Node.js

const cluster = require('cluster');
const http = require('http');

if (cluster.isMaster) {
  cluster.fork();
  cluster.fork();
} else {
  http.createServer((req, res) => {
    res.end(`Handled by worker ${process.pid}`);
  }).listen(3000);
  console.log(`Worker ${process.pid} started`);
}

A Only one worker starts successfully; the other throws an error because the port is already in use.

B Both workers start but only the first handles requests; the second is idle.

C Both workers start and share the port; requests are load balanced between them, each responding with its own PID.

D The master process handles requests and workers do not start.

💡 Hint

Consider how Node.js cluster module manages server ports across workers.

The cluster module allows multiple worker processes to listen on the same port. The master distributes incoming connections among workers, enabling load balancing.