Node.js: Code Outside the Browser / Node.js Internals and How it Works

Processes, Threads and Thread Pool

🎯 Goal of This Note

Understand what a thread is, why Node.js runs in a single thread, and how the thread pool helps handle heavier tasks without blocking that thread.

🖥️ What Is a Process?

  • When you run Node.js, your computer starts a process — just a fancy word for "a program that's currently running."

  • Since Node.js is really a C++ program under the hood, running it creates a real, actual process at the operating system level — same as opening Chrome or any other app.

  • Because of this, Node gives you access to a built-in process variable in your code — it exists precisely because Node itself is an OS process. You'll use this later in the course.

🧵 What Is a Thread?

  • A thread is simply a sequence of instructions being run.

  • Think of it as a "box" where your code actually executes on the computer's processor — that's all you need to know for now.

⭐ Node.js Runs on a Single Thread

  • 🧵 Node apps run inside just one thread — whether you have 10 users or 10 million, they all share it.

  • ⚠️ Since there's only one thread, it's easy to accidentally block the whole app if you're not careful. This is one of Node's most important characteristics.

🚀 What Happens When a Node App Starts

  1. ▶️ Top-level code runs first — anything not inside a callback (e.g. reading files at the top of index.js)

  2. 📦 Modules load — core, custom, and third-party

  3. 📝 Callbacks get registered — e.g. the function passed to http.createServer() is set up, but doesn't run yet

  4. 🔄 The event loop starts — this is where most of the actual work happens; the "heart" of Node

⚠️ The Problem: Some Tasks Are Too Heavy

  • Certain operations would block the single thread if run directly in the event loop — bad for a server handling many users.

✅ The Solution: Thread Pool

  • 🧰 Provided by libuv, the thread pool gives Node 4 extra threads (configurable up to 128).

  • 🔄 The event loop automatically offloads heavy tasks to these threads, keeping the main thread free.

  • 🤖 This happens automatically — developers don't choose what gets offloaded.

📋 What Gets Offloaded?

📂 Category

📝 Examples

📁 File system

Reading/writing files

🔐 Cryptography

Password hashing, encryption

🗜️ Compression

Zipping/unzipping

🌐 DNS lookups

Domain → IP resolution

These are exactly the tasks most likely to block the main thread — so Node routes them to the thread pool instead.

🔑 Key Takeaways

📌 Concept

✅ Explanation

💻 Process

A running instance of a program (Node itself, as a C++ program)

🧵 Thread

A sequence of instructions — "where code executes"

🧵 Single thread

True no matter how many users — makes blocking code dangerous

▶️ Top-level code

Runs first, immediately, not inside a callback

🔄 Event loop

Starts after setup; handles ongoing work — Node's "heart"

🧰 Thread pool

4 (up to 128) extra threads from libuv, for heavy tasks

🤖 Auto-offloading

Node/libuv decide automatically — not developer-controlled

📋 Offloaded tasks

File ops, crypto, compression, DNS lookups