How does the Node.js event loop handle concurrent connections, and what are the common patterns to avoid blocking it?

Node.js Single-Threaded Event Loop

Node.js uses a single thread for JavaScript execution but handles I/O asynchronously via libuv (C library with a thread pool for I/O operations).

┌──────────────────────────┐
│     Event Loop (1 thread) │
│  ┌─────────────────────┐ │
│  │  Timers              │ │
│  │  Pending callbacks   │ │
│  │  Idle, prepare       │ │
│  │  Poll (I/O)          │◄──── libuv thread pool (4 threads)
│  │  Check (setImmediate)│ │
│  │  Close callbacks     │ │
│  └─────────────────────┘ │
└──────────────────────────┘

The Blocking Problem

// ❌ BLOCKS the event loop for ALL users
app.get("/users", (req, res) => {
  const data = fs.readFileSync("users.json"); // Sync = blocks thread
  const processed = heavySyncComputation(data); // CPU-bound = blocks thread
  res.json(processed);
});
// While this runs, ALL other requests wait in the queue

Fixes

1. Use Async I/O

// ✅ Non-blocking I/O
app.get("/users", async (req, res) => {
  const data = await fs.promises.readFile("users.json", "utf-8");
  res.json(JSON.parse(data));
});

2. Offload CPU-heavy Work

// ✅ Worker threads for CPU-bound tasks
const { Worker } = require("worker_threads");

app.get("/process", (req, res) => {
  const worker = new Worker("./heavy-task.js", {
    workerData: { input: req.body }
  });
  worker.on("message", (result) => res.json(result));
  worker.on("error", (err) => res.status(500).json({ error: err.message }));
});

3. Use Streams for Large Data

// ✅ Stream processing — constant memory
app.get("/export", (req, res) => {
  const stream = fs.createReadStream("large-file.csv");
  stream.pipe(csvParser()).pipe(res);
});

Performance Comparison

Approach	Blocks Event Loop?	Memory	Concurrency
readFileSync	✅ Yes	2x file size	1 request at a time
readFile (async)	❌ No	2x file size	Thousands
createReadStream	❌ No	Constant	Thousands
Worker Thread	❌ No	Worker overhead	CPU_COUNT parallel

The libuv Thread Pool

Default: 4 threads for file I/O, DNS lookups, etc. If all 4 are busy, I/O queues up.

# Increase thread pool size (max 128)
UV_THREADPOOL_SIZE=8 node server.js

Rule: Never use synchronous operations in request handlers. The event loop serves ALL users — blocking it blocks everyone.