Suggest an edit

Improve this article

Refine the answer for “Why is Node.js called a single-threaded environment?”. 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)

## What a "single-threaded environment" even means

**Single-threaded** means that **all JavaScript execution** in Node.js happens **on one main thread**.

That thread:

- runs your JS code,
- handles events, callbacks, promises and async functions,
- is driven by a mechanism called the **event loop**.

So at any given moment, Node.js **runs only one piece of JS code**, never several at once.

## Why it's built this way

Node.js is built on the **V8** engine (the same one used in Google Chrome),
and JavaScript was **originally a single-threaded language** (designed for the browser, where everything runs on one thread to avoid conflicts when working with the DOM).

Node.js's creator, **Ryan Dahl**, used that property of JS
but added an **asynchronous, non-blocking I/O model** on top of it via the **libuv** library.

The result:

> One thread runs JavaScript, while I/O operations (files, network, databases) are delegated to background threads.

## How it works under the hood

```javascript
┌───────────────────────────────────┐
│        Your JS code (1 thread)    │  ← Event Loop
└───────────────────────────────────┘
              ↓
     ┌──────────────────────┐
     │     libuv ThreadPool │  ← 4-8 background threads
     └──────────────────────┘
              ↓
       OS: files, network, DNS
```

- The main thread (the event loop) **runs only JS**.
- If a file needs reading or a database query needs making,
Node.js **doesn't wait** for the result, it **hands the task to a background thread** (`libuv`).
- Once the operation finishes, the result goes back to the event loop, and a callback or `await` fires.

## An example

```javascript
const fs = require('fs');

console.log('A');
fs.readFile('text.txt', 'utf8', () => console.log('B'));
console.log('C');
```

**Result:**

```javascript
A
C
B
```

JS code runs sequentially (A → C).
The file read runs in the background.
Once the file is ready, the event lands in the event loop, and `console.log('B')` runs.

## Why Node.js isn't strictly "single-threaded" under the hood

Node.js **internally** uses several threads:

- The **event loop**, one thread for running JS.
- The **thread pool (libuv)**, several threads (4 by default) for I/O operations.
- **OS threads**, even lower, for the network stack and filesystem.

But! All of that is hidden from the developer, **your JS logic always runs on one thread**, which is why Node.js **is called a single-threaded environment**.

## Advantages of being single-threaded

1. **Simplicity:** no data races, no synchronization, no mutexes.
2. **High scalability:** the event loop plus non-blocking I/O let it serve thousands of requests at once.
3. **Fewer resources:** no need to spawn a thread per request.

## Disadvantages

1. **CPU-heavy operations block the event loop.**
If JS code runs long computations, the server stops responding.
Fix: `worker_threads`, `cluster`, task queues.
2. **One error, one process.**
Without error handling (`try/catch`, `process.on('uncaughtException')`), the whole server can go down.

## Can Node.js be made multi-threaded?

Yes, if you need to use every CPU core, Node.js offers:

| Mechanism | Module | What it does |
|---|---|---|
| **Cluster API** | `cluster` | Runs several copies of the Node.js process |
| **Worker Threads** | `worker_threads` | Runs JS code on separate threads |
| **Child Process** | `child_process` | Creates child processes for heavy tasks |

## Summary

| Criterion | Node.js |
|---|---|
| Thread running JS | One (the Event Loop) |
| Threads under the hood | Yes (the libuv ThreadPool) |
| Main model | Asynchronous, non-blocking |
| Advantages | Simplicity, efficient for I/O |
| Disadvantages | A poor fit for heavy computation |

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

For the reviewer

Note to the moderator (optional)

Visible only to the moderator. Helps review go faster.