อ่าน JSON ขนาดใหญ่ใน Python ให้เร็วขึ้น: ทดสอบจริง stdlib, orjson และ msgspec
สรุปสำคัญ: สคริปต์นับ Stars จาก NDJSON ชุดเดียวกัน ใช้เวลา 754 มิลลิวินาทีกับไลบรารี json มาตรฐาน แต่ใช้เพียง 146 มิลลิวินาทีกับการถอดรหัสแบบประกาศของ msgspec — และการทำขนานแบบหลายคอร์เพิ่มอีกหนึ่งระดับ บทความนี้ทดสอบ stdlib, orjson และ msgspec ทีละขั้นบนตัวอย่าง 61.4 MB และ 300,000 บรรทัด พร้อมอธิบายว่าการเร่งความเร็วแต่ละชั้นมาจากไหนและหมดกำลังตอนไหน

สิ่งที่ทำให้การ parse ใน Python ช้าลงไม่ใช่ตัวข้อความ JSON เอง แต่คือต้นทุนการเปลี่ยนทุกฟิลด์ให้เป็นออบเจกต์ Python เปลี่ยน parser ค่าเริ่มต้น สร้างออบเจกต์ให้น้อยลง ใช้คอร์ให้ครบ — แล้วงานนับชุดเดิมจะพุ่งจาก 0.08 GB/s ไปหลักสิบ GB/s
ข้อสังเกต: โค้ดเดียวกัน ต่างกันหนึ่งระดับ
งานคลาสสิก: ใน log NDJSON สไตล์ GitHub Events ให้นับว่า repository ใดได้รับดาวมากที่สุดในบรรดาเรกคอร์ดที่ type เท่ากับ WatchEvent บนเครื่องของผม (Ubuntu 22.04, Python 3.12, orjson 3.13, msgspec 0.22) ผมสร้างไฟล์ตัวอย่าง 61.4 MB จำนวน 300,000 บรรทัด แล้วรันสี่รูปแบบการทำงานคนละสามครั้งโดยเก็บผลดีที่สุด:
| รูปแบบ | เวลาดีที่สุด | ทรูพุตเทียบสัดส่วน | สัมพัทธ์ |
|---|---|---|---|
json.loads ทีละบรรทัด |
754 ms | 0.08 GB/s | 1× (ฐาน) |
orjson.loads ทีละบรรทัด |
248 ms | 0.24 GB/s | 3.0× |
msgspec ถอดรหัสเป็น dict |
201 ms | 0.30 GB/s | 3.8× |
msgspec Struct แบบประกาศ |
146 ms | 0.41 GB/s | 5.2× |
ทั้งสี่รูปแบบให้จำนวนดาวเท่ากันเป๊ะ (60,108 เรกคอร์ด) แปลว่าส่วนต่างทั้งหมดมาจากการ parse ล้วน ๆ ข้อมูลบุคคลที่สามก็สนับสนุนระดับเดียวกัน: ในเบนช์มาร์กที่ World Programming เผยแพร่วันที่ 2026-11-14 สถิติเดียวกันบนข้อมูล 7.6 GB และเหตุการณ์ GitHub Archive 2.2 ล้านรายการ วิ่งที่ 0.28 GB/s ด้วยไลบรารีมาตรฐาน (ราว 27 วินาที) เร็วขึ้นราว 8 เท่าเมื่อเปลี่ยนเป็น msgspec ส่วน fastsimdjson ที่ใช้ SIMD ประมวลผลชุดข้อมูลทั้งหมดเสร็จใน 55 ms บน 192 เธรด (138 GB/s) และไฟล์เดี่ยวสูงสุดแตะ 277 GB/s ข้อสังเกต: เครื่องของเขาคือ AWS c8a.metal-48xl 192 คอร์ ตัวเลขจึงย้ายไปใช้กับโน้ตบุ๊กตรง ๆ ไม่ได้ — แต่รูปทรงบันไดเหมือนกัน
ไลบรารีมาตรฐานเสียเวลาตรงไหน
แนวทาง json.loads ทีละบรรทัดทำ "การแปลแบบเต็ม" ทุกขั้น: parser กวาดผ่าน {"id": 1, "type": "WatchEvent", ...} สร้าง dict ใหม่ ออบเจกต์ str อย่างน้อยเจ็ดตัว และ int หลายตัวสำหรับเรกคอร์ดเดียวนั้น แล้วส่งการอ้างอิงให้โค้ดของคุณ สามแสนบรรทัดแปลว่าการจัดสรรออบเจกต์เล็ก ๆ หลายล้านครั้ง ซึ่งคุณไม่เคยแตะส่วนใหญ่เลย — งานนับอ่านแค่สองฟิลด์ คือ type และ repo.name
ข้อจำกัดที่สองคือ GIL ใน CPython มีเพียงหนึ่งเธรดที่รันไบต์โค้ด Python ในแต่ละช่วงเวลา และแม้โค้ด C ของ parser จะปล่อย GIL ตรรกะกรองและรวมยอดของคุณในลูปก็ยังทำเรียงลำดับ เปิดแปดเธรดบนอินเทอร์พรีเตอร์ค่าเริ่มต้นจึงไม่แก้อะไรเลย ต้องเปลี่ยนวิธีคิด
ขั้นเร่งความเร็วที่หนึ่ง: เปลี่ยน parser
เป็นขั้นที่ให้ผลตอบแทนต่อความพยายามดีที่สุด — การเปลี่ยนมีแค่ import:
import json
import orjson
import msgspec
dec = msgspec.json.Decoder()
# สาม parser ใช้อินเทอร์เฟซเกือบเหมือนกัน ยกเว้น dumps:
# orjson.dumps(...) คืน bytes ไม่ใช่ str
for name, load in [("stdlib", json.loads), ("orjson", orjson.loads), ("msgspec", dec.decode)]:
stars = {}
with open("events.ndjson", "rb") as f:
for line in f:
e = load(line)
if e["type"] == "WatchEvent":
stars[e["repo"]["name"]] = stars.get(e["repo"]["name"], 0) + 1
orjson เขียนด้วย Rust สร้างไบต์ UTF-8 ระหว่าง parse โดยตรง และใช้คำสั่ง SIMD อย่างจัดเต็ม บนเครื่องผมเร็วขึ้นสามเท่า มีกับดัก API ที่ควรจำ: orjson.dumps() คืน bytes ไม่ใช่ str — ต้องจัดการเวลาเขียนไฟล์หรือต่อสตริง
การถอดรหัสค่าเริ่มต้นของ msgspec อยู่ระดับเดียวกับ orjson (3.8×) แต่อาวุธจริงคือการถอดรหัสแบบประกาศ — สร้างออบเจกต์ Python เฉพาะฟิลด์ที่ประกาศไว้:
import msgspec
class Event(msgspec.Struct):
type: str
repo: msgspec.Raw # ยังไม่ถอดรหัส เก็บไบต์ดิบไว้
dec = msgspec.json.Decoder(Event)
stars = {}
with open("events.ndjson", "rb") as f:
for line in f:
e = dec.decode(line)
if e.type == "WatchEvent":
name = msgspec.json.decode(e.repo)["name"]
stars[name] = stars.get(name, 0) + 1
พอประกาศ repo เป็น msgspec.Raw บรรทัดที่ไม่ใช่ WatchEvent จำนวน 240,000 บรรทัดจะข้ามการสร้างออบเจกต์ repo ทั้งหมด ทำแค่กวาดโทเคน — การกระโดดจาก 3.8× ไป 5.2× มาจากจุดนี้พอดี เรกคอร์ดยิ่งมีฟิลด์มากและอัตราทิ้งยิ่งสูง ขั้นนี้ยิ่งคุ้ม
ขั้นที่สอง: แบ่งงานข้ามโปรเซส แต่ผลลดลงเรื่อย ๆ
พอคอร์เดียวอิ่มตัว คำตอบคลาสสิกคือโปรเซสพูล: แบ่งไฟล์เป็น N ช่วงไบต์ (จัดให้ตรงขอบบรรทัด) ส่งแต่ละชิ้นให้โปรเซสลูกจับนับ แล้วรวม Counter ตอนจบ แต่ละโปรเซสคืนเพียงตารางผลลัพธ์เล็ก ๆ ต้นทุนการสื่อสารจึงต่ำมาก — เป็นรูปแบบอุดมคติของ map-reduce
เบนช์มาร์กของ World Programming ฉายภาพเส้นทางนี้ให้เห็น: โปรเซสพูลของ msgspec พีคที่ 116 GB/s เมื่อใช้ 96 โปรเซส และเพิ่มโปรเซสต่อไปกลับช้าลง — ต้นทุนการจัดตารางและการรวมกลืนกินกำไร มีข้อจำกัดจริงสองข้อ: ชิ้นส่วนต้องตรงกับอักขระขึ้นบรรทัดใหม่ ไม่งั้นบรรทัดสุดท้ายของแต่ละชิ้น parse ล้มเหลว และงานประเภทนับ (คืนผลเล็ก) เป็นกรณีที่ดีที่สุดของโปรเซสพูล ถ้าต้องดึงเรกคอร์ดทุกตัวออกมาใช้ การส่งข้ามโปรเซสจะกลายเป็นคอขวดตัวใหม่เอง
ขั้นที่สาม: SIMD และ Python ไร้ GIL
fastsimdjson เดินทางคนละสาย: 8 GB/s บนคอร์เดียว (ราว 3.5 เท่าของ msgspec) เพราะยืนบนการจัดดัชนีเชิงโครงสร้างของ simdjson — กวาดเครื่องหมายวรรคตอนล่วงหน้าเพื่อหาตำแหน่งโทเคนแต่ละตัวโดยไม่สร้างต้นไม้ออบเจกต์เต็มรูป คู่กับ fields=["/type", "/repo/name"] จะอ่านเฉพาะเส้นทาง JSON Pointer ที่ประกาศไว้ และคอลแบ็กได้รับแค่สองค่านั้น
มันยังทำหลายเธรดได้ด้วย: จับคู่กับบิลด์ free-threaded ของ Python 3.14 (python3.14t ความพยายามทางการของ PEP 703 ที่จะถอด GIL) เธรด 192 เธรดประมวลผล 7.6 GB จบใน 55 ms บนไฟล์เบนช์มาร์กสาธารณะขนาดราว 1 GB จำนวนหกไฟล์ สี่ไฟล์ทะลุ 100 GB/s และไฟล์เร็วสุดคือชุด twitter แตะ 277 GB/s อย่าลืมว่านี่คือการวัดซ้ำอิสระที่เกินคำกล่าวอ้างของผู้ผลิต และตัวอย่างเป็นสถานการณ์ที่เอื้อที่สุด — "อ่านหนึ่งถึงสองฟิลด์ต่อเรกคอร์ด" เอกสารที่ซ้อนลึกไปถึงตัวเลขระดับนั้นไม่ได้ มีไฟล์หนึ่งค้างอยู่แถว ๆ 20 GB/s
ตารางเลือกอย่างเร็วและลำดับการนำไปใช้
| เส้นทาง | กลไก | ทรูพุต (เครื่องเรา/อ้างอิง) | เหมาะกับ |
|---|---|---|---|
json (stdlib) |
สร้างออบเจกต์เต็ม คอร์เดียว | 0.08 GB/s | ไฟล์เล็ก ไม่พึ่งพาภายนอก |
| orjson | Rust + SIMD สร้างออบเจกต์เต็ม | 0.24 GB/s | สลับใช้ด้วยไม่กี่บรรทัด |
| msgspec dict | Rust สร้างออบเจกต์เต็ม | 0.30 GB/s | เลือกอย่างใดอย่างหนึ่งกับ orjson |
| msgspec Struct | ถอดรหัสเฉพาะฟิลด์ที่ประกาศ | 0.41 GB/s | อาร์เรย์ใหญ่ อัตราทิ้งสูง |
| msgspec หลายโปรเซส | ขนานตามชิ้นส่วน | อ้างอิง 116 GB/s | งานรวมยอด ผลลัพธ์เล็ก |
| fastsimdjson | ดัชนีโครงสร้าง + หลายเธรด | อ้างอิง 138-277 GB/s | ดึงฟิลด์จาก NDJSON, 3.14t |
ลำดับการนำไปใช้ที่สมเหตุสมผล: เปลี่ยนไปใช้ msgspec หรือ orjson ก่อน (ใช้เวลาไม่กี่นาทีแลก 3-5 เท่าฟรี) ถ้ายังไม่พอ แปลงฟิลด์เส้นทางร้อนเป็น Struct งานประเภทนับเพิ่มโปรเซสพูล fastsimdjson พิจารณาเฉพาะเมื่อคุณดึงฟิลด์ทีละบรรทัดจาก NDJSON และสภาพแวดล้อมอนุญาต ถ้าคอขวดคือหน่วยความจำไม่ใช่ความเร็ว — ไฟล์ใหญ่เกินอ่านทั้งฉบับ — ทิศทางเปลี่ยน: ย้ายไปสตรีมกับ ijson หรือ jq --stream บนคอมมานด์ไลน์ ดู ประมวลผล JSON ใหญ่แบบสตรีมด้วย jq และ การ parse, เรนเดอร์ และสตรีม JSON ขนาดใหญ่ กฎการอ่าน-เขียนทีละบรรทัดของ NDJSON อยู่ใน คู่มือปฏิบัติไฟล์ JSONL
วินัยการวัดผลและสามกับดัก
หนึ่ง ตรึงวิธีจับเวลาให้คงที่: ในบทความนี้แต่ละรูปแบบรันสามครั้งและเก็บผลดีที่สุด (กรองสั่นของตัวจัดตาราง) และไฟล์ถูกสร้างเสร็จก่อนเริ่มจับเวลา เวลาอ้างตัวเลขของคนอื่นให้บอกสเปกเครื่องด้วย — อย่าเอา 138 GB/s บน 192 คอร์ไปเทียบกับคอร์เดียวของโน้ตบุ๊กตัวเองเด็ดขาด
สอง ตรวจความถูกต้องแบบไขว้: ทั้งสี่รูปแบบนับดาวได้ 60,108 ดอกเท่ากัน การ "เร่ง" แบบใดก็ตามที่ทำให้ตัวเลขเปลี่ยน แปลว่าเซแมนติกของการ parse เปลี่ยน (การจัดการคีย์ซ้ำ ความละเอียดของจำนวนเต็มใหญ่) ไม่ใช่เร็วขึ้น เทียบผลก่อน ค่อยเทียบความเร็ว
สาม สามกับดักที่เจอบ่อย: orjson.dumps() คืน bytes ผสมกับ str จะเกิดข้อมูลสกปรกมีคำนำหน้า b'...' แบบเงียบ ๆ ชิ้นส่วนโปรเซสพูลต้องตรงขอบบรรทัด — หลัง f.seek(offset) ทิ้งบรรทัดครึ่ง ๆ ก่อน จำนวนเต็มใหญ่เกิน 2^53 ปลอดภัยใน parser Python ทุกตัว แต่ถ้าผลลัพธ์ไปฝั่ง JavaScript ปัญหาความละเอียดรออยู่ที่นั่นแล้ว
คำถามที่พบบ่อย
ควรเลือก orjson หรือ msgspec?
ถ้าแค่อยากได้ loads ที่เร็วขึ้น ทั้งคู่ให้ 3 เท่าขึ้นไป — เลือกตามการดูแลรักษาที่แข็งแรงและความคุ้นเคยของทีม เลือก msgspec เมื่อต้องการถอดรหัสบางส่วน (msgspec.Struct + Raw) ตรวจชนิดข้อมูล หรือเอาต์พุตแบบ TypedDict/dataclass การถอดรหัสแบบประกาศของมันเพิ่มกำไรอีกชั้นบนอาร์เรย์ใหญ่โดยอิสระ
หลายโปรเซสเร็วกว่าคอร์เดียวเสมอไปหรือไม่?
ไม่ การแบ่ง การเปิดโปรเซส และการรวมกลับมีต้นทุนคงที่ กับไฟล์สักสิบกว่า MB มักขาดทุน งานที่คืนผลใหญ่ (ต้องเอาทุกเรกคอร์ด) เสียกำไรไปกับการส่งข้อมูล ตามกฎประสบการณ์: เปลี่ยนไลบรารีบนคอร์เดียวก่อน แล้วขนานเมื่อถึงระดับ GB ในงานนับล้วน ๆ
ทำไมเบนช์มาร์ก orjson ของผมไม่ขึ้น 3 เท่า?
สามเหตุผลที่พบบ่อย: ตัวอย่างเล็กเกินไป (เวลา parse จมอยู่ในการอ่านไฟล์และต้นทุนลูป) คอขวดจริงคือเครือข่ายหรือดิสก์ไม่ใช่การ parse หรือข้อมูลเป็นสตริงยาวเกือบทั้งหมด การสร้างออบเจกต์จึงถ่วงน้อย เปลี่ยนไปใช้ตัวอย่างใหญ่ขึ้น คลุมเฉพาะลูป parse ด้วย time.perf_counter แล้วค่อยสรุป
ijson เกี่ยวข้องกับไลบรารีเหล่านี้อย่างไร?
ijson เป็นอิเทอเรเตอร์แบบสตรีม สละทรูพุตเพื่อหน่วยความจำคงที่ เหมาะกับไฟล์ที่ใหญ่กว่าแรมมาก orjson/msgspec ล่าทรูพุตแต่เปลี่ยนทุกเรกคอร์ดเป็นออบเจกต์ สองฝ่ายไม่ขัดกัน: NDJSON ระดับ GB จัดการได้ด้วยการอ่านทีละบรรทัดบวกถอดรหัสเร็วด้วย msgspec ส่วน ijson หรือ jq --stream จำเป็นเฉพาะเอกสาร JSON เดี่ยวที่มหึมาจริง ๆ