อ่าน JSON ขนาดใหญ่ใน Node.js: การ parse แบบสตรีมด้วย stream-json และ backpressure ในทางปฏิบัติ
สรุปสำคัญ: การอ่าน JSON array 186MB ด้วย readFileSync และ JSON.parse ดันหน่วยความจำขึ้นถึงจุดสูงสุด 612MB; เปลี่ยนไปใช้ streamArray จาก stream-json จะรักษาเส้นโค้งให้แบนที่ 104MB. บทความนี้เปรียบเทียบสี่กลยุทธ์การอ่านตามการวัดผล อธิบายว่าทำไม for await จึงสร้าง backpressure ให้โดยธรรมชาติ อีเวนต์ data สูญเสียมันอย่างไร และวิธีตั้ง highWaterMark กับ drain ฝั่งเขียน.

เมื่อการ import ไฟล์ JSON 186MB ดันกระบวนการขึ้นไปถึง 600MB ของหน่วยความจำ ตัวร้ายไม่ใช่ขนาดไฟล์ — JSON.parse แลกข้อความทั้งหมดกับ object graph ทั้งหมดในครั้งเดียว เปลี่ยนกลยุทธ์การอ่านแล้วเส้นโค้งหน่วยความจำจะแบนราบ
อาการหนึ่ง: ไฟล์ 186MB ที่พีกถึง 612MB
งาน import ฝั่งเซิร์ฟเวอร์เป็นพื้นที่ที่ปัญหานี้พบมากที่สุด: การซิงก์คำสั่งตามตารางเวลา การทำความสะอาดล็อก การโหลดประวัติเป็นชุด การติดตั้งแบบทั่วไปมีหน้าตาแบบนี้:
const fs = require('fs');
const raw = fs.readFileSync('./orders.json', 'utf8');
const orders = JSON.parse(raw);
for (const order of orders) await saveToDb(order);
เราได้วัดรูปแบบนี้บน Node 22.13 ตัวอย่าง: array ของออบเจ็กต์ 480,000 รายการคำสั่งซื้อ ไฟล์ 186MB มี string, object ซ้อนกัน และ array ในฟิลด์ จำลองโครงสร้างธุรกิจจริง จุดสูงสุดของ Maximum resident set size วัดด้วย /usr/bin/time -v: ไฟล์อ่านเสร็จใน 1.3 วินาที แต่ RSS พุ่งถึง 612MB — มากกว่าไฟล์ 3.3 เท่า เมื่อลิมิตเริ่มต้นของ old space ของ V8 อยู่ที่ 1.4–2GB มีงานแบบนี้แค่ไม่กี่งานที่รันขนานก็พอให้ container จบลงด้วย OOM Kill
เลขคณิตไม่ได้แปลกประหลาด: ข้อความดิบครองสำเนาหนึ่งในหน่วยความจำ (ประมาณ 186MB), object graph ที่ได้จาก parse ครองสำเนาที่สอง (ทุก string key, ทุกหัว object ที่ซ้อนกัน และทุก array มีต้นทุนเพิ่ม), และตัวกระบวนการ parse เองก็จัดสรรชั่วคราวซ้อนขึ้นไป การพุ่งถึง 600MB เป็นเรื่องปกติ
สาเหตุที่สอง: JSON.parse แลกข้อความทั้งหมดกับกราฟทั้งหมด
สัญญาของ JSON.parse คือ «ให้ข้อความฉบับเต็มมา — คืนกราฟฉบับเต็มให้» มันเรียกร้องให้ข้อความทั้งหมดพร้อมก่อนเริ่ม และส่งมอบผลลัพธ์เฉพาะตอนจบ ไม่มีกลไก «เอา 1,000 รายการแรกไปก่อน»
ต้นทุนของ object graph ถูกวัดรายข้อแล้วใน บัญชีหน่วยความจำของ JSON: ทุก string ครองพื้นที่จริง ทุกคีย์ object ครองหนึ่งช่อง และความกว้างของ array ขึ้นกับประเภทของสมาชิก JSON ระดับหลายสิบ MB มักกลายเป็นสามถึงห้าเท่าหลัง parse โดยจุดสูงสุดซ้อนขึ้นไปอีก
แต่งาน import ส่วนใหญ่ไม่เคยต้องการกราฟทั้งหมด: insert ทีละแถว กรองทีละแถว แปลงทีละแถว — ทุกรายการสามารถปล่อยได้ทันทีที่ประมวลผลแล้ว สิ่งที่งานต้องการคือความสามารถ «parse เสร็จหนึ่งรายการ — ส่งมอบหนึ่งรายการ» ซึ่งก็คือนิยามของการ parse แบบสตรีมพอดี
ทางแก้: streamArray ป้อนทีละรายการ และ for await ให้ backpressure ฟรี
stream-json ติดตั้ง parser เป็น Transform stream ที่กิน token และไม่เคยรอไฟล์ทั้งหมด เมื่อระดับบนสุดเป็น array, streamArray() จะ emit {key, value} ในช่วงเวลาที่แต่ละองค์ประกอบ parse เสร็จ:
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);
}
}
บนไฟล์ 186MB ชุดเดิมกับรายการ 480,000 รายการเดิม เวอร์ชันนี้มีพีก RSS ที่ 104MB แบนราบตลอดการรัน ในหน่วยความจำมีเพียง «องค์ประกอบปัจจุบัน + สถานะ parser» ณ เวลาใดก็ตาม รายการที่เสร็จถูกเก็บคืนทันที
รายละเอียดที่มองข้ามง่าย: for await ไม่ดึงรายการถัดไปจาก parser จนกว่า saveToDb จะเสร็จ ทำให้ parserหยุดอ่านไฟล์ ฐานข้อมูลช้าลง การอ่านก็ช้าลง — นั่นคือ backpressure ที่เกิดขึ้นเองโดยธรรมชาติ โดยไม่ต้องเขียนโค้ดเพิ่มแม้แต่บรรทัดเดียว บทความบน dev.to เรื่องการนำเข้าฟีดขนส่งเมือง 4GB ใช้ห่วงโซ่เดียวกันพร้อม pick({filter:'data'}) และรายงานเส้นโค้งหน่วยความจำแบนเช่นกัน
เมื่อฝั่งเขียนล้มเหลว: อีเวนต์ data ที่ไม่หยุดดันหน่วยความจำกลับขึ้น
การ parse แบบสตรีมคุมเฉพาะฝั่งอ่าน ถ้าฝั่งเขียนไม่รับ backpressure หน่วยความจำจะกลับมาสูงอีก ความล้มเหลวแบบคลาสสิกคือเขียนแบบอะซิงโครนัสใน handler data โดยไม่สนใจ buffer ของ writable:
// ผิด: อีเวนต์ data + เขียนอะซิงโครนัส backpressure สูญหายทั้งหมด
readable.on('data', async (chunk) => {
await slowWrite(chunk); // stream ไม่รอ buffer บวมต่อไป
});
ในโหมด data stream ยังไหลต่อ ไม่ว่า slowWrite จะช้าแค่ไหน ทุกอย่างกองอยู่ใน buffer ภายในของ writable บนตัวอย่าง 186MB ชุดเดียวกัน เรานำรายการไปที่ Writable ช้าที่หน่วง 1ms ทุกชั้นที่หนึ่งร้อย โดยไม่คุม backpressure พีก RSS ทะลุ 407MB; เมื่อระงับด้วย await once(sink, 'drain') เมื่อ write() คืน false — 161MB ส่วนต่าง 246MB คือ literally ข้อมูลที่นั่งอยู่ใน write buffer
// ถูกต้อง: หยุดเมื่อ write() คืน false เดินต่อที่ drain
for await (const { value } of pipeline) {
if (!sink.write(value)) {
await once(sink, 'drain');
}
}
โน้ตภาคสนามเพิ่มสองข้อ: เมื่อประกอบห่วงโซ่ stream ด้วยมือ ตั้ง highWaterMark อย่างชัดเจนทุก stream — ค่าเริ่มต้น 16 ใน objectMode มากเกินไปสำหรับออบเจ็กต์ใหญ่; และเลือก pipeline() จาก stream/promises แทน pipe(), ซึ่งรับผิดชอบการแพร่กระจายข้อผิดพลาดและการเก็บกวาด
การวัด: จุดสูงสุดหน่วยความจำของสี่กลยุทธ์
| กลยุทธ์ | ตัวอย่าง | พีก RSS | ระยะเวลา | ใช้เมื่อ |
|---|---|---|---|---|
| readFileSync + JSON.parse | 186MB / 480 พัน | 612MB | 1.3s | ไฟล์เล็ก เข้าถึงแบบสุ่ม |
| streamArray + for await + เขียน DB ช้า (0.5ms ต่อรายการ) | เดียวกัน | 104MB (แบน) | ตามจังหวะ DB | นำเข้าทีละรายการ แปลงรูป |
| streamArray + เขียนผ่าน data ไม่มี backpressure | เดียวกัน | 407MB | ~10s | ตัวอย่างที่ไม่ควรทำ |
| streamArray + write()/drain | เดียวกัน | 161MB | ~10s | เขียนดิสก์หรือส่งต่อ |
สภาพแวดล้อม: Node 22.13, Maximum resident set size จาก /usr/bin/time -v, ตัวอย่างสังเคราะห์ฟิลด์แบบธุรกิจ, รันเดี่ยวไม่เฉลี่ย, จำลองการเขียนช้าด้วย setTimeout. ตัวเลขเหล่านี้เป็นข้อสรุประดับขนาดสำหรับตัวอย่างนี้ ไม่ใช่ค่าคงที่สากล — วัดกับข้อมูลของคุณเอง
สองค่าที่น่าสนใจ กลยุทธ์ที่หนึ่งและสองต่างกันหกเท่าในหน่วยความจำ แลกกับเปลี่ยน «1.3 วินาที» เป็น «ความเร็ว DB». สามกับสี่ต่างกัน 2.5 เท่า: อ่านแบบสตรีมโดยเขียนไม่มี backpressure แก้ปัญหาได้เพียงครึ่งเดียว
การวินิจฉัย: ยืนยันว่า backpressure ทำงานจริง
ปัญหาหน่วยความจำใน production แก้ด้วยสัญชาตญาณไม่ได้ วัสดุของ Tencent Cloud เรื่องค้นหาที่ผิดพลาด backpressure ให้แผนปฏิบัติที่ใช้ได้:
- ล็อกชั่วคราวอีเวนต์
'pause'และ'resume'บน stream วิกฤต ถ้าไปป์ไลน์ปริมาณสูงไม่เคย pause เลย ที่ไหนสักแห่งกำลังกองข้อมูลในหน่วยความจำ; - เฝ้าดู
writable.writableLength— การเติบโตต่อเนื่องแปลว่า buffer ไม่เคยลดลง; - สุ่มตัวอย่าง RSS ด้วย
process.memoryUsage()เป็นระยะและวาดเส้นโค้ง แยก «การเติบโตแบบลาด» (สะสม) กับ «เสถียรแบบฟันเลื่อย» (ปล่อยสุขภาพดี)
ภายใต้ความหมายของ for await อีเวนต์ pause กับ resume ต้องสลับกัน ถ้าไม่เคยยิง ให้หา listener data เกินมาหรือ await ที่ลืม
เมื่อไหร่ streaming ไม่ใช่คำตอบ
Streaming ไม่ใช่คำตอบเริ่มต้น สำหรับไฟล์ไม่กี่สิบ MB ที่ต้องเข้าถึงแบบสุ่มตามคีย์ การเรียก JSON.parse หนึ่งครั้งง่ายและถูกกว่า การเปิดไฟล์ใหญ่ในเบราว์เซอร์เป็นโดเมนปัญหาอื่น — วิธีเปิดไฟล์ JSON ใหญ่ครอบคลุมบันได viewer ขอบเขตของการ parse แบบสตรีมชัดเจน:
- ระดับบนสุดเป็น array (หรือข้อมูลแยกเป็น JSONL ได้) การบริโภคเป็นลำดับ ไม่ต้องมองย้อน;
- ขนาดไฟล์ควบคุมไม่ได้หรือเกินหมอก heap มาก และ import หนึ่งครั้งไม่ควรเพิ่ม footprint ของกระบวนการเป็นสองเท่า;
- ผู้บริโภคมีส่วนต่างความเร็วตามธรรมชาติ (เขียน DB, การเรียก API ปลายน้ำ) จึงต้องการ backpressure ไม่ใช่ท่อพลังเต็มสูบ
เมื่อรูปร่างระดับบนสุดไม่สม่ำเสมอ ดูโครงสร้างก่อนในเครื่องมือ parser และ formatter JSON; สายเทียบบรรทัดคำสั่งอยู่ใน jq กับ JSON ใหญ่ — jq --stream กับ streamArray เป็นความคิดเดียวกันในสอง runtime
FAQ
stream-json ช้ากว่า JSON.parse เท่าไร?
การ parse ล้วน JSON.parse ชนะ: 1.3 วินาทีสำหรับตัวอย่าง 186MB เทียบกับราว 7 วินาทีของ streamArray ไม่มีดีเลย์เขียน (parse token บวกการสร้างออบเจ็กต์ทีละรายการ) ผลประโยชน์ของ streaming อยู่ครบฝั่งหน่วยความจำ: พีกลดจาก 612MB เหลือ 104MB งาน import ก็ติดขัดที่เขียน DB อยู่แล้ว จ่ายแลกเวลา parse ไม่กี่วินาทีเพื่อหมอกหน่วยความจำหกเท่ามักเป็นข้อตกลงที่ดี ภายในการตอบ API ระดับมิลลิวินาที ไม่ใช่
backpressure ของ for await เหมือน pause/resume ด้วยมือหรือไม่?
ในเชิงความหมายใช่: for await ระงับ stream ที่อ่านได้ขณะ body ลูปยังค้าง เทียบเท่ากับเรียก pause() เมื่อ write() คืน false และ resume() ที่ drain ต่างกันที่กลไกของภาษาทำบัญชีเองและไม่ลืมอะไร; การเดินสายด้วยมือเสีย backpressure ของทั้งห่วงโซ่เมื่อพลาดจุดเดียว
ถ้าระดับบนสุดเป็นออบเจ็กต์เดียวยักษ์ล่ะ?
stream-json มี streamObject() (emit ตามคีย์) และตัวกรอง Pick (parse เฉพาะ subtree ที่เลือก) ถ้าต้องการเพียงบางฟิลด์ Pick กับ JSONPath หดกราฟทั้งหมดให้เหลือ subgraph ที่ต้องการ อินพุตหลายเอกสาร (JSON Lines, ลำดับ JSON) ควรแยกทีละบรรทัดและประมวลผลเป็นเอกสารอิสระ
เขียนผลลัพธ์เป็น JSONL หรือส่งต่อปลายน้ำทำอย่างไร?
ฝั่งเขียนคือคำถาม backpressure เดียวกัน: fs.createWriteStream และ http.request ต้องตรวจค่าที่คืนจาก write() และรอ once(stream, 'drain') เมื่อ false — หรือเสียบ writable เข้า pipeline(). การตรวจสอบง่าย: เส้นโค้ง RSS หลังรันหนึ่งรอบต้องเสถียรและ writableLength ไม่เติบโตต่อเนื่อง
มอนิเตอร์หน่วยความจำที่เร็วที่สุดสำหรับงาน import คืออะไร?
เวอร์ชันต่ำสุด: ตัวจับเวลาสุ่มตัวอย่าง process.memoryUsage().rss ทุก 100ms ลงอาเรย์และพิมพ์ค่ามากสุดตอนจบ แม่นกว่า: /usr/bin/time -v node task.js ให้ Maximum resident set size ตรง ๆ ใน container วางเส้นเตือนที่ 70% ของลิมิตหน่วยความจำ เผื่อที่ว่างให้ GC