Fullstack Node.js & React
Trang chủ / Module 3
🟩 Module 3 / 19 · 4 ngày 📅 Tuần 2 ●●●○ Khó

Node.js runtime từ bên trong: event loop, streams, worker, bộ nhớ

Node hoạt động thế nào bên dưới (V8 + libuv), 6 pha của event loop, xử lý dữ liệu lớn bằng stream, việc nặng CPU bằng worker thread, và tìm memory leak.

libuvStreamsWorker threadsMemory leakESM
📌 Vì sao module này quan trọng

Nhiều developer viết Node 3 năm mà vẫn coi nó là hộp đen — cho đến khi server dùng 100% CPU vì một JSON.parse file 200MB, hoặc RAM tăng dần rồi bị OOM kill mỗi 6 tiếng. Hiểu runtime là thứ tách người "viết được API" khỏi người "chịu trách nhiệm được một service production". Đây cũng là nhóm câu hỏi phỏng vấn backend Node gần như chắc chắn xuất hiện.

🎯 Mục tiêu học tập

  • Mô tả kiến trúc V8 + libuv + thread pool và việc gì chạy ở đâu
  • Kể 6 pha event loop của Node, phân biệt process.nextTick, setImmediate, setTimeout
  • Dùng stream và pipeline để xử lý file/HTTP lớn với bộ nhớ hằng số
  • Chọn đúng giữa async I/O, worker_threads, child_process và cluster
  • Tìm memory leak bằng heap snapshot; phát hiện event loop bị chặn

Kiến trúc: V8, libuv và thread pool

Thành phầnVai trò
V8Biên dịch và chạy JS (JIT), quản lý heap và garbage collector
libuvEvent loop + I/O bất đồng bộ. Network dùng cơ chế của OS (epoll/kqueue/IOCP) — không tốn thread
Thread pool (mặc định 4)Việc OS không hỗ trợ async: file system, dns.lookup, crypto.pbkdf2/scrypt, zlib

Hệ quả: 10.000 kết nối HTTP chờ DB không sao (network async), nhưng 10 request cùng băm mật khẩu bằng bcrypt đồng bộ sẽ làm mọi request khác đứng hình. Tăng pool bằng UV_THREADPOOL_SIZE chỉ là giải pháp tạm.

6 pha của event loop

   ┌──────────────────────────┐
┌─▶│ timers                   │  setTimeout, setInterval đã tới hạn
│  ├──────────────────────────┤
│  │ pending callbacks        │  một số callback I/O bị hoãn
│  ├──────────────────────────┤
│  │ idle, prepare            │  nội bộ
│  ├──────────────────────────┤
│  │ poll                     │  chờ & xử lý I/O mới  ◀── phần lớn thời gian ở đây
│  ├──────────────────────────┤
│  │ check                    │  setImmediate
│  ├──────────────────────────┤
└──┤ close callbacks          │  socket.on('close')
   └──────────────────────────┘
 Giữa MỖI callback: xả process.nextTick queue, rồi Promise microtask queue
  • process.nextTick chạy trước cả Promise — dùng lạm sẽ "bỏ đói" event loop.
  • Trong callback I/O, setImmediate luôn chạy trước setTimeout(fn, 0).
  • Đo độ trễ event loop: perf_hooks.monitorEventLoopDelay(). p99 > 100ms là có vấn đề.

Streams và backpressure

Stream xử lý dữ liệu theo từng chunk, nên export CSV 2GB chỉ tốn vài chục MB RAM. Backpressure: khi bên ghi chậm hơn bên đọc, stream tự tạm dừng nguồn — chỉ khi bạn dùng pipeline chứ không tự on('data').

import { pipeline } from 'node:stream/promises';
import { createReadStream, createWriteStream } from 'node:fs';
import { createGzip } from 'node:zlib';
import { Transform } from 'node:stream';

const upper = new Transform({
  transform(chunk, _enc, cb) { cb(null, chunk.toString().toUpperCase()); },
});

await pipeline(createReadStream('big.log'), upper, createGzip(), createWriteStream('big.log.gz'));

// Stream thẳng kết quả DB ra HTTP response: không load toàn bộ vào RAM
app.get('/export.csv', async (req, res) => {
  res.setHeader('Content-Type', 'text/csv');
  await pipeline(db.queryStream('SELECT * FROM orders'), toCsv(), res);
});

Việc nặng CPU: worker_threads, child_process, cluster

Công cụLà gìKhi dùng
worker_threadsThread JS riêng, chung tiến trình, trao đổi qua message/SharedArrayBufferResize ảnh, parse file lớn, tính toán — dùng qua pool (piscina)
child_processTiến trình riêngChạy ffmpeg, script Python, lệnh hệ thống
clusterNhiều tiến trình Node chung một cổngTận dụng nhiều core — nhưng trên Kubernetes/container, thường chạy nhiều pod 1 tiến trình thay vì cluster
Hàng đợi (BullMQ)Đẩy việc sang worker service khácViệc lâu > vài trăm ms không cần trả kết quả ngay — Module 7

Bộ nhớ, GC và memory leak

Nguồn leak hay gặp nhất trong Node:

  • Cache bằng Map toàn cục không giới hạn → dùng LRU có max size/TTL.
  • Event listener thêm mỗi request mà không gỡ (cảnh báo MaxListenersExceededWarning).
  • Closure giữ tham chiếu tới object lớn (request, buffer) sau khi xong việc.
  • setInterval không bao giờ clearInterval.
node --inspect dist/server.js          # mở chrome://inspect → Memory → Heap snapshot
node --heapsnapshot-signal=SIGUSR2 ...  # chụp snapshot trên production bằng signal
node --max-old-space-size=1536 ...      # đặt trần heap phù hợp với memory limit của container

Quy trình: chụp snapshot → bắn tải 5 phút → chụp lại → so sánh (Comparison view) để xem object nào tăng mà không giảm. Công cụ: Chrome DevTools, clinic.js (doctor, flame, heapprofiler).

Module system, process và graceful shutdown

  • ESM là mặc định cho dự án mới ("type": "module"). Node 22+ cho phép require() một module ESM đồng bộ, giảm đau đầu khi trộn CJS/ESM.
  • Luôn import module lõi bằng tiền tố node: (node:fs).
  • Built-in đáng dùng: fetch, node --watch, node --env-file=.env, test runner node:test.
// Graceful shutdown — bắt buộc khi chạy trong container
const server = app.listen(env.PORT);
const shutdown = async (signal: string) => {
  logger.info({ signal }, 'shutting down');
  server.close();                 // ngừng nhận kết nối mới, chờ request đang chạy
  await queue.close();
  await db.$disconnect();
  process.exit(0);
};
process.on('SIGTERM', shutdown);
process.on('SIGINT', shutdown);

🏋️ Bài tập thực hành

Chứng minh bằng số liệu

(1) Viết server có endpoint /block chạy vòng lặp 2 giây và endpoint /ping; dùng autocannon chứng minh /ping bị chặn, rồi chuyển việc nặng sang piscina worker và đo lại. (2) Export 1 triệu dòng CSV bằng stream, đo RSS so với cách load hết vào mảng. (3) Cố ý tạo memory leak (Map toàn cục), tìm ra nó bằng heap snapshot, viết lại bằng LRU. (4) Thêm graceful shutdown và chứng minh request đang chạy không bị cắt khi gửi SIGTERM.

📚 Tài nguyên học tập

✅ Tự đánh giá hoàn thành

  • Vẽ lại được kiến trúc V8 + libuv và 6 pha event loop
  • Xử lý file/response lớn bằng pipeline với bộ nhớ hằng số
  • Biết khi nào dùng worker thread, child process, queue
  • Tìm được một memory leak bằng heap snapshot
  • Server có graceful shutdown