How cluster module works in Node.js - Visual Walkthrough

Concept Flow - How cluster module works

Start Master Process

↓

Fork Worker Processes

↓

Workers Listen on Server Port

↓

Master Distributes Incoming Requests

↓

Workers Handle Requests Independently

↓

If Worker Dies

→Master Forks New Worker

↓

Continue Serving

The master process starts and forks multiple worker processes. Each worker listens on the same server port. The master distributes incoming requests to workers. If a worker dies, the master replaces it.

Execution Sample

Node.js

import cluster from 'cluster';
import os from 'os';
import http from 'http';

if (cluster.isPrimary) {
  for (let i = 0; i < os.cpus().length; i++) cluster.fork();
} else {
  http.createServer((req, res) => res.end('Hello from worker')).listen(8000);
}

This code creates a master process that forks one worker per CPU core. Each worker runs an HTTP server on port 8000.

Execution Table

Step	Action	Process Type	Workers Count	Server Listening	Notes
1	Start script	Primary	0	No	Master process begins
2	Check if primary	Primary	0	No	True, will fork workers
3	Fork worker 1	Primary	1	No	First worker created
4	Fork worker 2	Primary	2	No	Second worker created
5	Fork worker N	Primary	N	No	All workers forked (N = CPU count)
6	Workers start server	Worker	N	Yes	Each worker listens on port 8000
7	Master distributes requests	Primary	N	No	Incoming requests load balanced
8	Worker handles request	Worker	N	Yes	Responds with 'Hello from worker'
9	Worker crashes	Worker	N-1	Yes	One worker dies
10	Master forks new worker	Primary	N	No	Worker count restored
11	Continue serving	Primary & Workers	N	Yes	Server runs continuously

💡 Server runs indefinitely until manually stopped

Variable Tracker

Variable	Start	After Fork 1	After Fork 2	After All Forks	After Worker Crash	After Replacement
cluster.isPrimary	true	true	true	true	true	true
workers count	0	1	2	N (CPU count)	N-1	N
server listening	No	No	No	Yes (in workers)	Yes	Yes

Key Moments - 3 Insights

Why do all workers listen on the same port without conflict?

The cluster module uses OS-level load balancing so multiple workers can share the same port safely, as shown in execution_table rows 6 and 7.

What happens if a worker process crashes?

The master detects the crash and forks a new worker to keep the count stable, as seen in rows 9 and 10 of the execution_table.

Is the master process handling requests directly?

No, the master only manages workers and distributes requests. Workers handle requests independently (rows 7 and 8).

Visual Quiz - 3 Questions

Look at the execution_table, at which step do workers start listening on the server port?

A Step 9

B Step 3

C Step 6

D Step 2

💡 Hint

Check the 'Server Listening' column in execution_table row 6

According to variable_tracker, what happens to the workers count after a worker crashes?

A It decreases by one

B It increases

C It stays the same

D It becomes zero

💡 Hint

Look at 'workers count' row in variable_tracker after 'After Worker Crash' column

If the master process did not fork new workers after a crash, what would happen to the workers count?

A It would remain at N

B It would decrease and not recover

C It would increase unexpectedly

D It would reset to zero

💡 Hint

Refer to execution_table rows 9 and 10 about worker crash and replacement

Concept Snapshot

Node.js cluster module lets a master process fork multiple worker processes.
Workers share the same server port using OS load balancing.
Master manages workers and replaces any that crash.
This improves app performance by using multiple CPU cores.
Workers handle requests independently, master only manages.

Full Transcript

The Node.js cluster module works by starting a master process that forks multiple worker processes equal to the number of CPU cores. Each worker runs an HTTP server listening on the same port. The master process distributes incoming requests across these workers using operating system load balancing. If a worker crashes, the master detects this and forks a new worker to maintain the number of active workers. This setup allows Node.js applications to handle more requests concurrently by using all CPU cores efficiently. The master process itself does not handle requests but manages the workers. Workers independently respond to requests, improving performance and reliability.