Đọc JSON lớn trong Node.js: phân tích luồng với stream-json và backpressure trong thực tế
Kết luận: Đọc một mảng JSON 186MB bằng readFileSync và JSON.parse đẩy bộ nhớ lên đỉnh 612MB; chuyển sang streamArray của stream-json giữ đường cong phẳng ở 104MB. Bài viết so sánh bốn chiến lược đọc theo phép đo, giải thích vì sao for await sinh backpressure tự nhiên, sự kiện data mất nó thế nào và cách cấu hình highWaterMark cùng drain ở phía ghi.

Khi nhập một tệp JSON 186MB đẩy tiến trình lên 600MB bộ nhớ, thủ phạm không phải là kích thước tệp — JSON.parse đã trao toàn bộ văn bản lấy toàn bộ đồ thị đối tượng trong một lần. Đổi chiến lược đọc, đường cong bộ nhớ sẽ phẳng lì.
Một triệu chứng: tệp 186MB với đỉnh 612MB
Các công việc nhập phía máy chủ là địa bàn này hay gặp nhất: đồng bộ đơn hàng theo lịch, làm sạch log, nạp lịch sử hàng loạt. Cách cài đặt điển hình trông như thế này:
const fs = require('fs');
const raw = fs.readFileSync('./orders.json', 'utf8');
const orders = JSON.parse(raw);
for (const order of orders) await saveToDb(order);
Chúng tôi đã đo mẫu này trên Node 22.13. Mẫu: mảng 480.000 bản ghi đơn hàng, tệp 186MB với chuỗi, đối tượng lồng nhau và mảng trong các trường, mô phỏng cấu trúc kinh doanh thật. Đỉnh Maximum resident set size theo /usr/bin/time -v: tệp đọc xong trong 1.3 giây, nhưng RSS chạm 612MB — gấp 3.3 lần tệp. Với hạn mức mặc định old space của V8 1.4–2GB, vài công việc như vậy chạy song song là đủ để container bị OOM Kill.
Phép tính không gì lạ: văn bản thô chiếm một bản sao trong bộ nhớ (khoảng 186MB), đồ thị đối tượng sau parse chiếm bản sao thứ hai (mỗi khóa chuỗi, mỗi đầu đối tượng lồng và mỗi mảng đều có chi phí), và chính quá trình phân tích còn cấp phát tạm thời chồng lên. Đạt đỉnh 600MB là bình thường.
Nguyên nhân thứ hai: JSON.parse trao toàn bộ văn bản lấy toàn bộ đồ thị
Hợp đồng của JSON.parse là «cho tôi toàn bộ văn bản — trả lại toàn bộ đồ thị». Nó yêu cầu toàn bộ văn bản sẵn sàng trước khi bắt đầu và chỉ giao kết quả khi kết thúc. Không tồn tại cơ chế «đây trước 1.000 bản ghi đầu».
Chi phí của đồ thị đối tượng đã được đo từng mục trong Sổ kế toán bộ nhớ của JSON: mỗi chuỗi chiếm không gian thật, mỗi khóa đối tượng chiếm một ô, và chiều rộng mảng phụ thuộc loại phần tử. Vài chục MB JSON thường xuyên phình ra gấp ba đến gấp năm sau phân tích, đỉnh chồng lên trên nữa.
Nhưng phần lớn công việc nhập chưa bao giờ cần cả đồ thị: chèn từng dòng, lọc từng dòng, biến đổi từng dòng — mỗi bản ghi có thể được giải phóng ngay sau khi xử lý. Việc cần là khả năng «phân tích xong một bản ghi — giao một bản ghi». Đó chính là định nghĩa của phân tích luồng.
Giải pháp: streamArray tiêu thụ từng bản ghi, và for await sinh backpressure sẵn
stream-json cài đặt trình phân tích như một Transform stream tiêu thụ token và không bao giờ chờ cả tệp. Khi tầng trên cùng là mảng, streamArray() phát {key, value} ngay khoảnh khắc từng phần tử phân tích xong:
const fs = require('fs');
const { chain } = require('stream-chain');
const { parser } = require('stream-json');
const { streamArray } = require('stream-json/streamers/StreamArray');
async function importOrders(filePath) {
const pipeline = chain([
fs.createReadStream(filePath, { highWaterMark: 64 * 1024 }),
parser(),
streamArray(),
]);
for await (const { key, value } of pipeline) {
await saveToDb(value);
}
}
Trên cùng tệp 186MB với cùng 480.000 bản ghi, phiên bản này có đỉnh RSS 104MB, phẳng suốt toàn bộ lần chạy. Trong bộ nhớ mỗi lúc chỉ tồn tại «phần tử hiện tại + trạng thái trình phân tích»; các bản ghi xong được thu hồi ngay.
Chi tiết dễ bỏ sót: for await không kéo bản ghi kế tiếp từ trình phân tích cho đến khi saveToDb hoàn tất, nên trình phân tích ngừng đọc tệp. Cơ sở dữ liệu chậm hơn, đọc chậm hơn — đó là backpressure, hình thành tự nhiên, không cần một dòng mã thêm. Bài trên dev.to về nạp dòng giao thông đô thị 4GB dùng đúng chuỗi này với pick({filter:'data'}) và báo đường cong bộ nhớ cũng phẳng như vậy.
Khi phía ghi thất thủ: sự kiện data không tạm dừng đẩy bộ nhớ trở lại
Phân tích luồng chỉ kỷ luật hóa phía đọc. Nếu phía ghi không nhận backpressure, bộ nhớ lại leo lên. Sự sụp đổ kinh điển: ghi bất đồng bộ trong handler data mà không ngó nghịch buffer của writable:
// Sai: sự kiện data + ghi bất đồng bộ, backpressure mất hoàn toàn
readable.on('data', async (chunk) => {
await slowWrite(chunk); // stream không chờ; buffer cứ phình to
});
Ở chế độ data stream vẫn chảy, dù slowWrite chậm thế nào, và tất cả dồn vào buffer nội bộ của writable. Trên cùng mẫu 186MB, chúng tôi dẫn các bản ghi vào một Writable chậm trễ 1ms ở mỗi khối thứ một trăm. Bỏ qua backpressure, đỉnh RSS đạt 407MB; tạm dừng bằng await once(sink, 'drain') khi write() trả về false, 161MB. Chênh 246MB là literally dữ liệu đang ngồi trong buffer ghi.
// Đúng: tạm dừng khi write() trả về false, tiếp tục ở drain
for await (const { value } of pipeline) {
if (!sink.write(value)) {
await once(sink, 'drain');
}
}
Hai ghi chú thêm: khi tự lắp chuỗi stream, đặt highWaterMark tường minh trên mỗi stream — giá trị mặc định 16 trong objectMode quá hào phóng cho đối tượng lớn; và ưu tiên pipeline() từ stream/promises thay vì pipe(), gánh cả lan truyền lỗi và dọn dẹp.
Các phép đo: đỉnh bộ nhớ của bốn chiến lược
| Chiến lược | Mẫu | Đỉnh RSS | Thời gian | Dùng khi |
|---|---|---|---|---|
| readFileSync + JSON.parse | 186MB / 480 nghìn | 612MB | 1.3s | tệp nhỏ, truy cập ngẫu nhiên |
| streamArray + for await + ghi DB chậm (0.5ms mỗi lệnh) | như nhau | 104MB (phẳng) | theo nhịp DB | nạp từng bản ghi, biến đổi |
| streamArray + ghi qua data, không backpressure | như nhau | 407MB | ~10s | ví dụ xấu |
| streamArray + write()/drain | như nhau | 161MB | ~10s | ghi đĩa hoặc chuyển tiếp |
Môi trường: Node 22.13, Maximum resident set size từ /usr/bin/time -v, mẫu tổng hợp với trường theo dạng kinh doanh, chạy đơn không lấy trung bình, mô phỏng ghi chậm bằng setTimeout. Những con số này là kết luận về bậc độ lớn cho mẫu này, không phải hằng số phổ quát — hãy đo trên dữ liệu của bạn.
Hai chỉ số đáng chú ý. Chiến lược một và hai khác nhau gấp sáu lần về bộ nhớ, đổi lại «1.3 giây» thành «tốc độ DB». Ba và bốn khác nhau gấp 2.5 lần: đọc luồng mà ghi không có backpressure chỉ giải quyết được nửa bài.
Chẩn đoán: xác nhận backpressure thực sự hoạt động
Vấn đề bộ nhớ trên production không giải quyết bằng linh cảm. Bài của Tencent Cloud về tìm lỗi backpressure đưa quy trình thực dụng:
- Tạm thời log sự kiện
'pause'và'resume'trên các stream quan trọng. Nếu đường ống lưu lượng lớn không bao giờ pause, ở đâu đó dữ liệu đang dồn trong bộ nhớ; - Theo dõi
writable.writableLength— tăng liên tục nghĩa là buffer không bao giờ cạn; - Lấy mẫu RSS bằng
process.memoryUsage()theo khoảng và vẽ đường cong, phân biệt «tăng dốc» (tích tụ) với «ổn định răng cưa» (thu hồi lành mạnh).
Dưới ngữ nghĩa for await, các sự kiện pause và resume phải xen kẽ; nếu không bao giờ nổ, tìm listener data thừa hoặc await bị quên.
Khi nào streaming không phải là câu trả lời
Streaming không phải câu trả lời mặc định. Với tệp vài chục MB cần truy cập ngẫu nhiên theo khóa, một lệnh JSON.parse đơn giản và rẻ hơn. Mở tệp lớn trong trình duyệt là một phạm vi vấn đề khác — cách mở tệp JSON lớn nói về bậc thang trình xem. Ranh giới của phân tích luồng rất rõ:
- tầng trên cùng là mảng (hoặc dữ liệu chia được như JSONL), tiêu thụ tuần tự, không cần nhìn lại;
- kích thước tệp không kiểm soát hoặc vượt xa dư địa heap, và một lần nhập không được nhân đôi dấu chân bộ nhớ của tiến trình;
- bên tiêu thụ có độ trễ tốc độ tự nhiên (ghi DB, gọi API hạ nguồn), cần backpressure chứ không phải ống mở hết cỡ.
Khi hình dạng tầng trên không đều, hãy xem cấu trúc trước trong công cụ trình phân tích và định dạng JSON; phương án dòng lệnh nằm ở jq với JSON lớn — jq --stream và streamArray là một ý tưởng ở hai runtime.
FAQ
stream-json chậm hơn JSON.parse bao nhiêu?
Ở phân tích thuần, JSON.parse thắng: 1.3 giây cho mẫu 186MB, so với khoảng 7 giây cho streamArray không có trễ ghi (phân tích token cộng dựng đối tượng từng bản ghi). Lợi ích của streaming nằm trọn ở phía bộ nhớ: đỉnh rơi từ 612MB xuống 104MB. Công việc nhập vốn kẹt ở ghi DB, nên trả thêm vài giây phân tích lấy biên bộ nhớ gấp sáu thường là món hời; trong phản hồi API cỡ mili giây thì không.
Backpressure của for await có phải là pause/resume thủ công không?
Về ngữ nghĩa là có: for await tạm dừng stream có thể đọc trong khi thân vòng lặp treo, tương đương gọi pause() khi write() trả về false và resume() khi drain. Khác biệt: cơ chế của ngôn ngữ giữ sổ sách và không quên gì cả; đi dây thủ công mất backpressure của cả chuỗi chỉ khi một chỗ bị sót.
Nếu tầng trên là một đối tượng khổng lồ duy nhất thì sao?
stream-json có streamObject() (phát theo khóa) và bộ lọc Pick (chỉ phân tích cây con được chọn). Nếu chỉ cần vài trường, Pick với JSONPath thu cả đồ thị về cây con cần thiết. Đầu vào đa tài liệu (JSON Lines, chuỗi JSON) nên tách theo dòng và xử lý như các tài liệu độc lập.
Làm sao ghi kết quả ra JSONL hoặc chuyển tiếp xuôi dòng?
Phía ghi là cùng câu hỏi backpressure: fs.createWriteStream và http.request đều phải kiểm tra giá trị trả về của write() và chờ once(stream, 'drain') khi false — hoặc nối writable vào pipeline(). Kiểm chứng đơn giản: đường cong RSS sau một lần chạy phải ổn định và writableLength không được tăng liên tục.
Trình theo dõi bộ nhớ nhanh nhất cho công việc nhập là gì?
Phiên bản tối thiểu: một bộ đếm lấy mẫu process.memoryUsage().rss mỗi 100ms vào mảng và in giá trị lớn nhất ở cuối. Chính xác hơn: /usr/bin/time -v node task.js cho thẳng Maximum resident set size. Trong container, đặt ngưỡng cảnh báo ở 70% hạn mức bộ nhớ để chừa dư địa cho GC.