JSON Toolkit

خواندن سریع JSON بزرگ در پایتون: آزمون stdlib، orjson و msgspec

جمع‌بندی: همان اسکریپت شمارش Stars از NDJSON با کتابخانه json استاندارد ۷۵۴ میلی‌ثانیه طول می‌کشد، اما با رمزگشایی اعلانی msgspec فقط ۱۴۶ میلی‌ثانیه، و موازی‌سازی چند هسته‌ای باز هم یک مرتبه بزرگی اضافه می‌کند. این مقاله stdlib و orjson و msgspec را گام‌به‌گام روی نمونه ۶۱٫۴ مگابایتی با ۳۰۰ هزار خط آزموده و توضیح می‌دهد هر شتاب‌گیری از کجا می‌آید و کجا به پایان می‌رسد.

پیشرفتهحدود 6 دقیقه مطالعهانتشار 2026-11-15به‌روزرسانی 2026-11-15
مقایسه مسیرهای شتاب‌دهی تجزیه JSON بزرگ در پایتون: stdlib، orjson، msgspec و موازی‌سازی چند هسته‌ای

آن‌که تجزیه را در پایتون کند می‌کند هرگز خودِ متن JSON نیست، بلکه هزینه تبدیل هر فیلد به یک شیء پایتون است. تجزیه‌گر پیش‌فرض را عوض کنید، شیء کمتر بسازید، همه هسته‌ها را به کار بگیرید — و همان کار شمارش از ۰٫۰۸ GB/s به ده‌ها GB/s می‌رسد.

یک مشاهده: همان کد، یک مرتبه بزرگی فاصله

کار رایج است: در لاگی NDJSON به سبک GitHub Events بشمارید کدام مخازن میان رکوردهایی که type آن‌ها WatchEvent است، بیشترین ستاره را می‌گیرند. روی دستگاه من (Ubuntu 22.04، Python 3.12، orjson 3.13، msgspec 0.22) یک فایل نمونه ۶۱٫۴ مگابایتی با ۳۰۰ هزار خط ساختم و چهار پیاده‌سازی را هر سه بار اجرا کردم و بهترین نتیجه را نگه داشتم:

پیاده‌سازی بهترین زمان توان عملیاتی معادل نسبی
json.loads خط به خط ۷۵۴ م.ث 0.08 GB/s ۱× (مبنا)
orjson.loads خط به خط ۲۴۸ م.ث 0.24 GB/s 3.0×
msgspec رمزگشایی به dict ۲۰۱ م.ث 0.30 GB/s 3.8×
msgspec Struct اعلانی ۱۴۶ م.ث 0.41 GB/s 5.2×

هر چهار پیاده‌سازی دقیقاً شمار ستاره‌های یکسانی دادند (۶۰٬۱۰۸ رکورد)، پس تمام تفاوت از خود تجزیه می‌آید. داده‌های شخص ثالث همین مرتبه بزرگی را تأیید می‌کنند: در بنچمارکی که World Programming در ۲۰۲۶-۱۱-۱۴ منتشر کرد، همان آمار روی ۷٫۶ گیگابایت و ۲٫۲ میلیون رویداد GitHub Archive با کتابخانه استاندارد با 0.28 GB/s اجرا می‌شد (حدود ۲۷ ثانیه)، با msgspec حدود ۸ برابر سریع‌تر بود، و fastsimdjson مبتنی بر SIMD کل مجموعه داده را در ۵۵ میلی‌ثانیه روی ۱۹۲ رشته پردازش کرد (138 GB/s) و روی یک فایل تا 277 GB/s رسید. دقت کنید دستگاه آن‌ها AWS c8a.metal-48xl با ۱۹۲ هسته است، پس این اعداد مستقیماً به لپ‌تاپ منتقل نمی‌شوند — اما شکل نردبان همان است.

کتابخانه استاندارد کجا زمان از دست می‌دهد

رویکرد json.loads خط به خط در هر گام یک «ترجمه کامل» انجام می‌دهد: تجزیه‌گر {"id": 1, "type": "WatchEvent", ...} را می‌پیماید، برای آن یک رکورد یک dict تازه، دست‌کم هفت شیء str و چند int می‌سازد و سپس ارجاع‌ها را به کد شما می‌دهد. سیصد هزار خط یعنی میلیون‌ها تخصیص کوچک شیء که بیشترشان را هرگز لمس نمی‌کنید — کار شمارش فقط دو فیلد را می‌خواند، type و repo.name.

محدودیت دوم GIL است. در CPython در هر لحظه فقط یک رشته بایت‌کد پایتون اجرا می‌کند، و حتی اگر کد C تجزیه‌گر GIL را آزاد کند، منطق فیلتر و انباشت شما داخل حلقه همچنان ترتیبی است. باز کردن هشت رشته روی مفسر پیش‌فرض هیچ چیز را حل نمی‌کند؛ باید راهبرد را عوض کرد.

پله اول شتاب: تجزیه‌گر را عوض کنید

این گام بالاترین بازده نسبت به تلاش را دارد — تنها تغییر، import است:

import json
import orjson
import msgspec

dec = msgspec.json.Decoder()

# سه تجزیه‌گر تقریباً یک رابط دارند، جز dumps:
# orjson.dumps(...) به جای str، bytes برمی‌گرداند
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 تولید می‌کند و به‌وفور از دستورهای SIMD استفاده می‌کند؛ روی دستگاه من سه برابر سریع‌تر بود. یک تله API هست که باید به یاد داشت: orjson.dumps() به جای str برمی‌گرداند bytes، پس هنگام نوشتن فایل یا چسباندن رشته‌ها به آن رسیدگی کنید.

رمزگشایی پیش‌فرض msgspec هم‌رده orjson است (3.8×)، اما سلاح واقعی آن رمزگشایی اعلانی است — فقط برای فیلدهای اعلام‌شده شیء پایتون می‌سازد:

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 ساخت شیء repo را کاملاً رد می‌کنند و فقط توکن‌ها را می‌پیمایند — جهش از 3.8× به 5.2× دقیقاً از همین‌جا می‌آید. هر چه رکورد فیلد بیشتری داشته باشد و نسبت دورریز بالاتر باشد، سود این پله بیشتر است.

پله دوم: تقسیم چندفرایندی، با بازده نزولی

وقتی یک هسته اشباع شد، پاسخ کلاسیک استخر فرایند است: فایل را به N بازه بایتی تقسیم کنید (هم‌تراز با مرز خطوط)، هر برش را به یک فرایند کارگر بسپارید و در پایان Counterها را ادغام کنید. هر فرایند فقط یک جدول کوچک نتیجه برمی‌گرداند، پس هزینه ارتباط حداقلی است — شکل ایده‌آل map-reduce.

بنچمارک World Programming شکل این مسیر را هم نشان می‌دهد: استخر فرایند msgspec با ۹۶ فرایند به اوج 116 GB/s رسید و افزودن فرایند بیشتر آن را کندتر می‌کرد — هزینه زمان‌بندی و ادغام سود را می‌بلعید. دو محدودیت عملی هم هست: برش‌ها باید با نویسه خط جدید هم‌تراز باشند وگرنه خط آخر هر برش در تجزیه شکست می‌خورد؛ و کارهای شمارشی (که نتیجه کوچک برمی‌گردانند) بهترین حالت برای استخر فرایندند. اگر باید هر رکورد را بیرون بکشید و مصرف کنید، خود انتقال بین فرایندها گلوگاه جدید می‌شود.

پله سوم: SIMD و پایتون بدون GIL

fastsimdjson راه دیگری می‌رود: 8 GB/s روی یک هسته (حدود ۳٫۵ برابر msgspec)، چون بر نمایه‌سازی ساختاری simdjson تکیه دارد — سجاوندی را از پیش می‌پیماید تا جای هر توکن را پیدا کند، بدون ساخت درخت کامل اشیاء؛ همراه با fields=["/type", "/repo/name"] فقط مسیرهای JSON Pointer اعلام‌شده را می‌خواند و فراخوانِ برگشتی فقط آن دو مقدار را می‌گیرد.

این کتابخانه چندرشته‌ای هم هست: همراه با نسخه free-threaded پایتون ۳٫۱۴ (python3.14t، تلاش رسمی PEP 703 برای حذف GIL)، ۱۹۲ رشته ۷٫۶ گیگابایت را در ۵۵ میلی‌ثانیه پردازش کردند. در شش فایل بنچمارک عمومی حدود ۱ گیگابایتی، چهار مورد از 100 GB/s گذشتند و سریع‌ترین، مجموعه twitter، به 277 GB/s رسید. توجه داشته باشید این‌ها اندازه‌گیری‌های مستقل فراتر از ادعای سازنده‌اند و نمونه در مطلوب‌ترین سناریوست — «خواندن یکی دو فیلد در هر رکورد». سندهای عمیقاً تودرتو به این اعداد نمی‌رسند؛ یکی از آن‌ها حدود ۲۰ GB/s ماند.

جدول انتخاب و ترتیب به‌کارگیری

مسیر سازوکار توان عملیاتی (محلی / مرجع) مناسب برای
json (stdlib) ساخت کامل شیء، یک هسته 0.08 GB/s فایل کوچک، بدون وابستگی
orjson Rust + SIMD، ساخت کامل شیء 0.24 GB/s جایگزینی در چند خط
msgspec dict Rust، ساخت کامل شیء 0.30 GB/s یکی از یا orjson یا msgspec
msgspec Struct فقط فیلدهای اعلام‌شده را رمزگشایی می‌کند 0.41 GB/s آرایه بزرگ، دورریز بالا
msgspec چندفرایندی موازی‌سازی برشی مرجع 116 GB/s تجمیع، نتیجه کوچک
fastsimdjson نمایه ساختاری + رشته‌ها مرجع 138-277 GB/s برداشت فیلد از NDJSON، 3.14t

ترتیب معقول به‌کارگیری: ابتدا به msgspec یا orjson بروید (چند دقیقه کار برای ۳ تا ۵ برابر رایگان)؛ اگر کافی نبود فیلدهای مسیر داغ را Struct کنید؛ برای کارهای شمارشی استخر فرایند اضافه کنید؛ fastsimdjson را فقط وقتی در نظر بگیرید که از NDJSON خط به خط فیلد بیرون می‌کشید و محیط اجرا اجازه دهد. اگر گلوگاه حافظه است نه سرعت — فایل آن‌قدر بزرگ است که نشود یک‌جا خواند — جهت عوض می‌شود: به استریمینگ ijson یا jq --stream در خط فرمان بروید؛ ببینید پردازش جریانی JSON بزرگ با jq و تجزیه، رندر و جریان JSON بزرگ. برای قواعد خط‌محور NDJSON ببینید راهنمای عملی فایل JSONL.

نظم اندازه‌گیری و سه تله

نخست، روش زمان‌گیری را ثابت نگه دارید: در این مقاله هر پیاده‌سازی سه بار اجرا و بهترین نتیجه پذیرفته می‌شود (برای حذف لرزش زمان‌بند)، و فایل پیش از شروع اندازه‌گیری کامل ساخته شده است. هنگام نقل اعداد دیگران مشخصات دستگاه را بگویید — هرگز 138 GB/s روی ۱۹۲ هسته را با یک هسته لپ‌تاپ خود مقایسه نکنید.

دوم، درستی را متقاطع راستی‌آزمایی کنید: شمار ستاره‌های هر چهار پیاده‌سازی ۶۰٬۱۰۸ بود. هر «شتاب‌گیری» که شمارش را عوض کند، معنای تجزیه را عوض کرده (رفتار کلید تکراری، دقت اعداد صحیح بزرگ)، نه سریع‌تر کرده. اول نتایج را منطبق کنید، بعد سرعت‌ها را.

سوم، سه تله رایج: orjson.dumps() بایت برمی‌گرداند و مخلوط‌کردنش با str بی‌سر و صدا داده کثیف با پیشوند b'...' می‌سازد؛ برش‌های استخر فرایند باید با مرز خطوط هم‌تراز باشند — بعد از f.seek(offset) اول خط ناقص را دور بریزید؛ اعداد صحیح بزرگ‌تر از 2^53 در هر تجزیه‌گر پایتون امن‌اند، اما اگر نتیجه به سمت جاوااسکریپت برود، مشکل دقت آن‌جا منتظرتان است.

پرسش‌های پرتکرار

orjson یا msgspec، کدام را انتخاب کنم؟

اگر فقط loads سریع‌تر می‌خواهید، هر دو ۳ برابر یا بیشتر می‌دهند — بر اساس فعالیت نگهداری و آشنایی تیم انتخاب کنید. msgspec را انتخاب کنید اگر رمزگشایی جزئی (msgspec.Struct + Raw)، اعتبارسنجی نوع یا خروجی TypedDict/dataclass لازم دارید؛ رمزگشایی اعلانی آن روی آرایه‌های بزرگ سود مستقل دیگری هم می‌افزاید.

آیا چندفرایندی همیشه از یک هسته سریع‌تر است؟

نه. تقسیم، راه‌اندازی فرایندها و ادغام هزینه ثابت دارند و با فایل چند ده مگابایتی معمولاً زیان‌ده است. کارهایی که نتیجه بزرگ برمی‌گردانند (به هر رکورد نیاز دارید) سودشان در انتقال از دست می‌رود. قاعده تجربی: اول روی یک هسته کتابخانه را عوض کنید، و فقط در مقیاس گیگابایت در کارهای صرفاً شمارشی موازی کنید.

چرا بنچمارک orjson من ۳ برابر نشان نمی‌دهد؟

سه دلیل رایج: نمونه خیلی کوچک است (زمان تجزیه در خواندن فایل و هزینه حلقه غرق می‌شود)؛ گلوگاه واقعی شبکه یا دیسک است نه تجزیه؛ یا داده‌ها تقریباً همه رشته‌های بلندند و سهم ساخت شیء کم است. نمونه بزرگ‌تر بگیرید، فقط حلقه تجزیه را در time.perf_counter بپیچید و بعد نتیجه بگیرید.

رابطه ijson با این کتابخانه‌ها چیست؟

ijson یک تکرارگر جریانی است: توان عملیاتی را فدای حافظه ثابت می‌کند و برای فایل‌های بسیار بزرگ‌تر از رم مناسب است؛ orjson/msgspec به دنبال توان عملیاتی‌اند اما هر رکورد را به شیء تبدیل می‌کنند. این دو با هم تناقض ندارند: NDJSON در مقیاس گیگابایت با خواندن خط به خط و رمزگشایی سریع msgspec حل می‌شود؛ ijson یا jq --stream فقط برای یک سند JSON تنها و بسیار بزرگ لازم است.