Suggest an edit

Improve this article

Refine the answer for “The importance of parallelism for scaling”. Your changes go to moderation before they’re published.

Approval required

Content

What you’re changing

Title (EN)

Short answer (EN)

Shown above the full answer for quick recall.

Answer (EN)

## 1. A quick reminder of the difference

> **Asynchrony != parallelism.**

- **Asynchrony**: Node.js can handle many I/O tasks *on a single thread* (through the event loop).
- **Parallelism**: genuinely running *several tasks at once* (on different processor cores).

Node.js uses **only one CPU core** by default.
To make efficient use of every core on the machine, we need **parallelism**.

## 2. Why asynchrony isn't enough

Asynchrony is a perfect fit for:

- I/O-heavy work (HTTP, filesystem, databases, network),
- a large number of light requests.

But when:

- the app does **heavy computation** (encryption, image processing, analytics),
- the server has **many CPU cores**,

one Node.js thread simply **can't use all the machine's resources**.

The result:

> One core is overloaded, the rest sit idle, so performance stops growing as load increases.

## 3. How parallelism solves this

Parallelism lets you:

- run **several Node.js processes or threads at once**;
- spread the load across every CPU core;
- handle **more requests** and **cut response time**.

Example:
On an 8-core server, you can run 8 instances of the app.
Each has its own event loop, its own JS thread.
→ Instead of 1,000 concurrent connections, you handle 8,000.

## 4. Parallelism mechanisms in Node.js

Node.js doesn't create threads automatically,
but it gives you tools for **explicit parallelism**:

| Approach | Module | What it's for |
|---|---|---|
| **Cluster API** | `cluster` | Running several Node.js processes (one per CPU core) |
| **Worker Threads** | `worker_threads` | Running JS code in parallel on different threads |
| **Child Process** | `child_process` | Spawning separate processes (for example, CLI tools, computation) |
| **PM2** | An external process manager | Managing clusters and auto-restarts |

### Example: clustering with `cluster`

```javascript
import cluster from 'cluster';
import os from 'os';
import http from 'http';

if (cluster.isPrimary) {
  const cores = os.cpus().length;
  console.log(`Starting ${cores} workers...`);
  for (let i = 0; i < cores; i++) cluster.fork();
} else {
  http.createServer((req, res) => {
    res.end(`Handled by worker ${process.pid}`);
  }).listen(3000);
}
```

What happens:

- The primary process creates workers, which are Node.js processes.
- Each worker listens on the same port and handles part of the requests.
- The OS distributes incoming connections between them.

Result:

> Load spreads evenly across cores, and the app scales horizontally.

### Example: heavy computation via `worker_threads`

```javascript
import { Worker } from 'worker_threads';

new Worker('./heavy-task.js'); // a separate thread, doesn't block the main one
```

Offloading CPU-intensive tasks to separate threads
frees up the main thread (the event loop) to serve requests.

## 5. Types of scaling

| Type | Description | Uses parallelism |
|---|---|---|
| **Vertical** | Using one server's resources (every CPU core) | Yes, via cluster or workers |
| **Horizontal** | Running the app on several servers | Yes, via a load balancer (Nginx, AWS, etc.) |

In practice, **both** approaches are usually combined:

- inside one server, a Node.js cluster across cores,
- outside it, load balancing across servers.

## 6. Advantages of parallelism in Node.js

| Advantage | Explanation |
|---|---|
| Higher performance | Uses every processor core |
| Error isolation | A crash in one worker doesn't take down the whole server |
| Horizontal scaling | You can run more workers or containers |
| Fast handling of heavy tasks | CPU-intensive operations don't block the event loop |
| Architectural flexibility | Functional zones can be split (API, cron, background jobs) |

## 7. Potential drawbacks

- Synchronizing between processes gets more complex.
- Memory isn't shared (each process has its own).
- Sometimes it's simpler to scale via a **load balancer** than inside Node.js itself.

## Summary

| Point | Essence |
|---|---|
| Node.js is single-threaded on its own | One event loop per process |
| Asynchrony = high I/O efficiency | But doesn't help under CPU load |
| Parallelism = using every core | Lets the app scale |
| Implementation | Via `cluster`, `worker_threads`, PM2, Docker |
| Benefit | Higher performance, resilience and scalability |

**Conclusion:**

> Parallelism is the key to scaling Node.js.
> It turns the "single-threaded" event loop into a system capable of using the full potential of multi-core processors.

Markdown · drag & drop images · ⌘B / ⌘I shortcuts707 words

For the reviewer

Note to the moderator (optional)

Visible only to the moderator. Helps review go faster.