Suggest an edit

Improve this article

Refine the answer for “Parallelism vs asynchrony”. 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)

## In short

| Concept | What it means |
|---|---|
| **Asynchrony** | A way of **organizing work** where the program doesn't wait for one operation to finish before starting another |
| **Parallelism** | Genuinely **running several operations at once** on different processor cores/threads |

## 1. Asynchrony is about **managing time**

Asynchrony lets the program avoid **blocking** while it waits for a result.

> The program can start a task, defer it, and work on another task until the first one finishes.

Example (Node.js, one thread):

```javascript
console.log("A");

setTimeout(() => console.log("B"), 1000);

console.log("C");
```

Output:

```javascript
A
C
B
```

Here **the code does not run in parallel**, but it does run **asynchronously**:
the timer fires later, and the thread never sits idle.

## 2. Parallelism is about **physically running at the same time**

Parallelism becomes possible when the CPU has multiple cores.
It literally runs several tasks **at the exact same moment**.

Example (a multi-threaded environment, like C++ or Python with multiprocessing):

```javascript
CPU core 1 → computes 1 + 1
CPU core 2 → computes 2 + 2 at the same time
```

Both operations genuinely happen **simultaneously**, not in turns.

## 3. Asynchrony without parallelism

Asynchrony **does not require** multithreading.

Node.js is a classic example:

- It's **single-threaded**, but **asynchronous**.
- While one operation (for example, `fs.readFile`) waits for a result, Node.js handles other events.
- Every task interleaves through the **event loop**.

In other words:

> Asynchrony = imitating simultaneity without real parallelism.

## 4. Parallelism without asynchrony

You can run tasks **in parallel**, yet **synchronously** inside each thread.

Example:

- Two cores run two functions at the same time.
- But each one is synchronous within its own thread.

## 5. Asynchrony and parallelism together

Sometimes both techniques are combined.

Example (Node.js + worker threads):

```javascript
const { Worker } = require('worker_threads');

new Worker('./worker1.js'); // thread 1
new Worker('./worker2.js'); // thread 2
```

- Inside each thread, JS runs asynchronously (through the event loop).
- The threads themselves run **in parallel** on different cores.

## 6. A real-life analogy

| Situation | What it illustrates |
|---|---|
| You put the kettle on and start washing dishes while the water boils | **Asynchrony**, you don't wait for one task to finish |
| You and a friend wash dishes at the same time | **Parallelism**, two tasks genuinely run at once |
| You and a friend wash dishes while the kettle boils itself | **Asynchrony + parallelism** |

## 7. Summary table

| Criterion | Asynchrony | Parallelism |
|---|---|---|
| What it is | A model for managing tasks | Physically simultaneous execution |
| Requires multiple threads? | No | Yes |
| Possible on a single core? | Yes | No |
| Where it's used | JS, Node.js, Python asyncio | C++, Java, Go, Rust |
| Implementation in Node.js | Event Loop + callbacks/promises | Worker Threads, Cluster |
| Example | `setTimeout`, `fs.readFile` | Several workers or processes |

## Summary

- **Asynchrony** means not blocking execution, so tasks interleave.
- **Parallelism** means tasks genuinely run at the same time.
- Node.js is **asynchronous**, but not parallel by default.
- Parallelism can be added when needed, via `worker_threads` or `cluster`.

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

For the reviewer

Note to the moderator (optional)

Visible only to the moderator. Helps review go faster.