When to use workers vs cluster in Node.js - Hands-On Comparison

When to Use Workers vs Cluster in Node.js

📖 Scenario: You are building a Node.js server that needs to handle multiple tasks efficiently. Some tasks are CPU-heavy, and others involve handling many client requests. You want to learn when to use worker_threads and when to use the cluster module to improve your server's performance.

🎯 Goal: Build a simple Node.js setup that demonstrates creating a worker thread for CPU-intensive work and a cluster to handle multiple server processes. This will help you understand when to use each approach.

📋 What You'll Learn

Create a worker thread to perform a CPU-heavy calculation

Create a cluster to spawn multiple server processes

Use exact variable and function names as instructed

Follow Node.js modern syntax with ES modules

💡 Why This Matters

🌍 Real World

Node.js servers often need to handle CPU-heavy tasks and many client requests simultaneously. Using workers and clusters helps improve performance and reliability.

💼 Career

Understanding workers and clusters is essential for backend developers working with Node.js to build scalable and efficient server applications.

1

Create a CPU-intensive task function

Create a function called heavyComputation that takes a number n and returns the sum of all numbers from 1 to n. Use a simple for loop inside the function.

Node.js

# Your code here
// Create function heavyComputation(n) that sums 1 to n

Hint

Use a for loop from 1 to n and add each number to a sum variable.

2

Set up a worker thread to run the CPU task

Import Worker from worker_threads. Create a new Worker instance called worker that runs a file named worker.js. This file will use the heavyComputation function.

Node.js

function heavyComputation(n) {
    let sum = 0;
    for (let i = 1; i <= n; i++) {
        sum += i;
    }
    return sum;
}

// Import Worker and create worker instance
// Your code here

Hint

Use import { Worker } from 'worker_threads' and create worker with new Worker(new URL('./worker.js', import.meta.url)).

3

Set up a cluster to handle multiple server processes

Import cluster and os modules. Create a variable numCPUs that stores the number of CPU cores using os.cpus().length. Use cluster.isPrimary to check if the current process is the primary. If yes, use a for loop with variable i from 0 to numCPUs to fork workers using cluster.fork().

Node.js

import { Worker } from 'worker_threads';
import cluster from 'cluster';
import os from 'os';

function heavyComputation(n) {
    let sum = 0;
    for (let i = 1; i <= n; i++) {
        sum += i;
    }
    return sum;
}

const worker = new Worker(new URL('./worker.js', import.meta.url));

// Create numCPUs and fork workers if primary
// Your code here

Hint

Use os.cpus().length to get CPU count and cluster.fork() inside a for loop to create workers.

4

Complete the cluster setup with a simple server

Inside the else block of if (cluster.isPrimary), create a simple HTTP server using import http from 'http'. The server should listen on port 3000 and respond with 'Hello from worker ' + process.pid for every request.

Node.js

import { Worker } from 'worker_threads';
import cluster from 'cluster';
import os from 'os';

function heavyComputation(n) {
    let sum = 0;
    for (let i = 1; i <= n; i++) {
        sum += i;
    }
    return sum;
}

const worker = new Worker(new URL('./worker.js', import.meta.url));

const numCPUs = os.cpus().length;

if (cluster.isPrimary) {
    for (let i = 0; i < numCPUs; i++) {
        cluster.fork();
    }
} else {
    // Create HTTP server that responds with worker pid
    // Your code here
}

Hint

Use http.createServer inside the else block and listen on port 3000.

Practice

1. What is the main reason to use worker_threads in Node.js instead of cluster?

easy

A. To restart crashed processes automatically

B. To create multiple server instances for load balancing

C. To share the same server port across processes

D. To run CPU-heavy tasks without blocking the main thread

Solution

1. Step 1: Understand worker_threads purpose

   Workers run code in separate threads to handle CPU-intensive tasks without blocking the main event loop.

2. Step 2: Compare with cluster usage

   Clusters create multiple processes to handle many incoming requests and improve server scalability, not for CPU-heavy tasks.

3. Final Answer:

   To run CPU-heavy tasks without blocking the main thread -> Option D

4. Quick Check:

   Workers = CPU tasks [OK]

Hint: Workers handle CPU tasks; clusters handle many requests [OK]

Common Mistakes:

• Confusing workers with clusters for load balancing
• Thinking clusters run in threads instead of processes
• Assuming workers share server ports automatically

2. Which of the following is the correct way to create a worker thread in Node.js?

easy

A. const worker = new Worker('worker.js');

B. const worker = cluster.fork('worker.js');

C. const worker = new Thread('worker.js');

D. const worker = new WorkerThread('worker.js');

Solution

1. Step 1: Recall worker_threads syntax

   The correct syntax to create a worker thread is using the Worker class from 'worker_threads' module: new Worker('filename').

2. Step 2: Identify incorrect options

   const worker = cluster.fork('worker.js'); uses cluster.fork which is for clusters, not workers. Options C and D use incorrect class names.

3. Final Answer:

   const worker = new Worker('worker.js'); -> Option A

4. Quick Check:

   Worker class = new Worker() [OK]

Hint: Use new Worker() from 'worker_threads' module [OK]

Common Mistakes:

• Using cluster.fork() to create workers
• Using wrong class names like Thread or WorkerThread
• Forgetting to import Worker from 'worker_threads'

3. Consider this Node.js code snippet using cluster:

const cluster = require('cluster');
if (cluster.isPrimary) {
  cluster.fork();
  cluster.fork();
} else {
  console.log('Worker process started');
}

What will be the output when you run this code?

medium

A. No output

B. Worker process started

C. Worker process started
Worker process started

D. SyntaxError

Solution

1. Step 1: Understand cluster.fork behavior

   cluster.fork() creates a new worker process that runs the same script but with cluster.isPrimary false.

2. Step 2: Count worker processes and output

   Two cluster.fork() calls create two workers, each printing 'Worker process started'. So output appears twice.

3. Final Answer:

   Worker process started Worker process started -> Option C

4. Quick Check:

   Two forks = two outputs [OK]

Hint: Each fork runs worker code once [OK]

Common Mistakes:

• Thinking only one worker runs
• Expecting output from primary process
• Confusing cluster.isPrimary with cluster.isWorker

4. This code tries to use workers but has an error:

const { Worker } = require('worker_threads');
const worker = new Worker('./worker.js');
worker.on('message', (msg) => console.log(msg));
worker.postMessage('start');

What is the likely problem here?

medium

A. The worker script must use parentPort to receive messages

B. You cannot send messages to workers using postMessage

C. Worker constructor requires a function, not a file path

D. Missing cluster module import

Solution

1. Step 1: Check worker communication setup

   Workers communicate via message passing. The worker script must listen on parentPort to receive messages.

2. Step 2: Identify missing code in worker.js

   If worker.js does not use parentPort.on('message'), it cannot handle messages sent by postMessage, causing no response or error.

3. Final Answer:

   The worker script must use parentPort to receive messages -> Option A

4. Quick Check:

   Worker script needs parentPort listener [OK]

Hint: Worker script must listen on parentPort for messages [OK]

Common Mistakes:

• Thinking postMessage is invalid for workers
• Confusing worker_threads with cluster usage
• Assuming Worker constructor takes a function directly

5. You have a Node.js server that handles many HTTP requests and also performs heavy image processing. How should you design your app using workers and cluster for best performance?

hard

A. Use only workers to run multiple server instances and process images

B. Use cluster to run multiple server processes and workers inside each process for image processing

C. Use only cluster to handle requests and do image processing in the main thread

D. Use a single process with no workers or cluster for simplicity

Solution

1. Step 1: Understand cluster for scaling servers

   Cluster creates multiple processes to handle many HTTP requests efficiently by using multiple CPU cores.

2. Step 2: Use workers for CPU-heavy tasks

   Heavy image processing should run in worker threads to avoid blocking the event loop in each server process.

3. Step 3: Combine cluster and workers

   Run cluster to scale server processes, and inside each process, use workers for heavy computation tasks.

4. Final Answer:

   Use cluster to run multiple server processes and workers inside each process for image processing -> Option B

5. Quick Check:

   Cluster for scaling + workers for CPU tasks [OK]

Hint: Cluster scales servers; workers handle heavy tasks inside each process [OK]

Common Mistakes:

• Doing heavy tasks in main thread blocking requests
• Using only workers without clustering for many requests
• Ignoring multi-core CPU benefits