JSON Toolkit

อ่าน JSON ขนาดใหญ่ใน Python ให้เร็วขึ้น: ทดสอบจริง stdlib, orjson และ msgspec

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

ขั้นสูงอ่านประมาณ 6 นาทีเผยแพร่ 2026-11-15อัปเดต 2026-11-15
เปรียบเทียบเส้นทางเร่งความเร็วการ parse JSON ขนาดใหญ่ใน Python: stdlib, orjson, msgspec และการทำขนานหลายคอร์

สิ่งที่ทำให้การ 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 เดี่ยวที่มหึมาจริง ๆ