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.
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ần | Vai trò |
|---|---|
| V8 | Biên dịch và chạy JS (JIT), quản lý heap và garbage collector |
| libuv | Event 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.nextTickchạy trước cả Promise — dùng lạm sẽ "bỏ đói" event loop.- Trong callback I/O,
setImmediateluôn chạy trướcsetTimeout(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_threads | Thread JS riêng, chung tiến trình, trao đổi qua message/SharedArrayBuffer | Resize ảnh, parse file lớn, tính toán — dùng qua pool (piscina) |
child_process | Tiến trình riêng | Chạy ffmpeg, script Python, lệnh hệ thống |
cluster | Nhiều tiến trình Node chung một cổng | Tậ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ác | Việ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
Maptoà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.
setIntervalkhô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éprequire()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 runnernode: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
(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
-
Node.js — The Node.js Event LoopTài liệu chính thức về các pha event loopDocs
-
Node.js — Don't Block the Event LoopHướng dẫn tránh chặn event loop và thread poolDocs
-
Node.js StreamsAPI stream và backpressureDocs
-
PiscinaWorker thread pool cho NodeRepo
-
Node.js Design Patterns (Casciaro, Mammino)Sách hay nhất về Node ở mức chuyên sâuSách
✅ 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