Membaca JSON besar dengan cepat di Python: uji coba stdlib, orjson, dan msgspec
Intinya: Skrip yang sama untuk menghitung Stars dari NDJSON butuh 754 ms dengan pustaka json standar tetapi hanya 146 ms dengan dekode deklaratif msgspec — dan paralelisme banyak inti menambah satu tingkat lagi. Artikel ini menguji stdlib, orjson, dan msgspec langkah demi langkah pada sampel 61,4 MB dan 300.000 baris, serta menjelaskan dari mana setiap percepatan berasal dan kapan ia habis.

Yang memperlambat parsing di Python bukanlah teks JSON itu sendiri, melainkan biaya mengubah setiap field menjadi objek Python. Ganti parser bawaan, bangun lebih sedikit objek, gunakan semua inti — dan pekerjaan penghitungan yang sama melompat dari 0,08 GB/s ke puluhan GB/s.
Satu pengamatan: kode yang sama, jarak satu tingkat
Tugasnya klasik: dalam log NDJSON bergaya GitHub Events, hitung repositori mana yang paling sering menerima bintang di antara catatan yang type-nya sama dengan WatchEvent. Di mesin saya (Ubuntu 22.04, Python 3.12, orjson 3.13, msgspec 0.22), saya membuat file sampel 61,4 MB dengan 300.000 baris dan menjalankan empat implementasi masing-masing tiga kali, menyimpan hasil terbaik:
| Implementasi | Waktu terbaik | Throughput skala | Relatif |
|---|---|---|---|
json.loads baris demi baris |
754 ms | 0,08 GB/s | 1× (dasar) |
orjson.loads baris demi baris |
248 ms | 0,24 GB/s | 3,0× |
msgspec dekode ke dict |
201 ms | 0,30 GB/s | 3,8× |
msgspec Struct deklaratif |
146 ms | 0,41 GB/s | 5,2× |
Keempat implementasi menghasilkan jumlah bintang yang persis sama (60.108 catatan), jadi seluruh perbedaan berasal dari parsing itu sendiri. Data pihak ketiga menopang tingkat yang sama: dalam benchmark yang dipublikasikan World Programming pada 2026-11-14, statistik yang sama atas 7,6 GB dan 2,2 juta peristiwa GitHub Archive berjalan 0,28 GB/s dengan pustaka standar (sekitar 27 detik), sekitar 8 kali lebih cepat dengan msgspec, sementara fastsimdjson berbasis SIMD menuntaskan seluruh kumpulan data dalam 55 ms pada 192 utas (138 GB/s), memuncak 277 GB/s pada satu file. Perhatikan: mesin mereka adalah AWS c8a.metal-48xl dengan 192 inti, jadi angka-angka ini tidak langsung berlaku di laptop — tetapi bentuk tangganya sama.
Di mana pustaka standar kehilangan waktu
Pendekatan json.loads baris demi baris melakukan "terjemahan lengkap" pada setiap langkah: parser memindai {"id": 1, "type": "WatchEvent", ...}, membuat dict baru, setidaknya tujuh objek str dan beberapa int untuk satu catatan itu saja, lalu menyerahkan referensinya ke kode Anda. Tiga ratus ribu baris berarti jutaan alokasi objek kecil, dan sebagian besar tak pernah Anda sentuh — pekerjaan penghitungan hanya membaca dua field, type dan repo.name.
Batas kedua adalah GIL. Dalam CPython, hanya satu utas yang menjalankan bytecode Python pada satu waktu, dan meskipun kode C parser melepas GIL, logika filter dan akumulasi Anda di dalam loop tetap serial. Membuka delapan utas pada interpreter bawaan tidak menyelesaikan apa pun; Anda perlu strategi lain.
Tingkat percepatan pertama: ganti parser
Ini langkah dengan imbal hasil terbaik untuk usaha — satu-satunya perubahan adalah import:
import json
import orjson
import msgspec
dec = msgspec.json.Decoder()
# Ketiga parser hampir berbagi antarmuka yang sama, kecuali dumps:
# orjson.dumps(...) mengembalikan bytes, bukan 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 ditulis dalam Rust, menghasilkan byte UTF-8 langsung saat parsing, dan memanfaatkan instruksi SIMD secara intensif; di mesin saya tiga kali lebih cepat. Ada satu jebakan API yang perlu diingat: orjson.dumps() mengembalikan bytes, bukan str — tangani itu saat menulis file atau menggabungkan string.
Dekode bawaan msgspec sekelas dengan orjson (3,8×), tetapi senjata sejatinya adalah dekode deklaratif — objek Python hanya dibangun untuk field yang dideklarasikan:
import msgspec
class Event(msgspec.Struct):
type: str
repo: msgspec.Raw # belum didekode, byte mentah disimpan
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
Begitu repo dideklarasikan sebagai msgspec.Raw, 240.000 baris tanpa WatchEvent melompati pembangunan objek repo sepenuhnya dan hanya memindai token — lompatan dari 3,8× ke 5,2× tepat berasal dari sini. Semakin banyak field sebuah catatan dan semakin tinggi rasio yang dibuang, semakin besar untung langkah ini.
Tingkat kedua: pembagian multiproses, dengan imbal hasil menurun
Ketika satu inti jenuh, jawaban klasiknya adalah pool proses: bagi file menjadi N rentang byte (diselaraskan dengan batas baris), serahkan tiap potongan ke satu proses pekerja, lalu di akhir gabungkan Counter. Setiap proses hanya mengembalikan satu tabel hasil kecil, jadi biaya komunikasi minim — bentuk ideal map-reduce.
Benchmark World Programming menunjukkan bentuk jalan ini: pool proses msgspec mencapai puncak 116 GB/s dengan 96 proses, dan menambah proses lagi justru memperlambat — biaya penjadwalan dan penggabungan melahap keuntungan. Dua batasan praktis berlaku: potongan harus selaras dengan karakter baris baru, jika tidak baris terakhir tiap potongan gagal diparse; dan tugas penghitungan (yang mengembalikan hasil kecil) adalah kasus terbaik untuk pool proses. Jika Anda harus menarik dan memakai setiap catatan, transfer antarproses itu sendiri menjadi hambatan baru.
Tingkat ketiga: SIMD dan Python tanpa GIL
fastsimdjson menempuh jalan lain: 8 GB/s pada satu inti (sekitar 3,5 kali msgspec), karena bertumpu pada pengindeksan terstruktur simdjson — memindai tanda baca di muka untuk menemukan posisi setiap token tanpa membangun pohon objek penuh; dikombinasikan dengan fields=["/type", "/repo/name"] ia hanya membaca jalur JSON Pointer yang dideklarasikan, dan callback hanya menerima dua nilai itu.
Ia juga multithread: dipasangkan dengan build free-threaded Python 3.14 (python3.14t, upaya resmi PEP 703 untuk menghapus GIL), 192 utas memproses 7,6 GB dalam 55 ms. Pada enam file benchmark publik berukuran sekitar 1 GB, empat melampaui 100 GB/s dan yang tercepat, dataset twitter, mencapai 277 GB/s. Ingatlah bahwa ini adalah pengukuran ulang independen di luar klaim vendor, dan sampelnya adalah skenario paling menguntungkan — "membaca satu-dua field per catatan". Dokumen dengan sarang dalam tidak mencapai angka tersebut; salah satunya hanya bertahan di sekitar 20 GB/s.
Tabel pilihan cepat dan urutan adopsi
| Jalur | Mekanisme | Throughput (lokal/referensi) | Paling cocok untuk |
|---|---|---|---|
json (stdlib) |
pembangunan objek penuh, satu inti | 0,08 GB/s | file kecil, tanpa dependensi |
| orjson | Rust + SIMD, pembangunan penuh | 0,24 GB/s | penggantian dalam beberapa baris |
| msgspec dict | Rust, pembangunan penuh | 0,30 GB/s | pilih salah satu dengan orjson |
| msgspec Struct | mendekode hanya field yang dideklarasikan | 0,41 GB/s | array besar, rasio buang tinggi |
| msgspec multiproses | paralel per potongan | referensi 116 GB/s | agregasi, kumpulan hasil kecil |
| fastsimdjson | indeks struktural + utas | referensi 138-277 GB/s | tarik field dari NDJSON, 3.14t |
Urutan adopsi yang masuk akal: pertama beralih ke msgspec atau orjson (beberapa menit kerja untuk 3-5× gratis); jika belum cukup, ubah field jalur panas menjadi Struct; untuk tugas penghitungan tambahkan pool proses; fastsimdjson hanya dipertimbangkan saat Anda menarik field baris demi baris dari NDJSON dan lingkungan Anda mengizinkan. Jika hambatannya adalah memori bukan kecepatan — file terlalu besar untuk dibaca utuh — arah berubah: pindah ke streaming dengan ijson, atau jq --stream di baris perintah; lihat Memproses JSON besar secara streaming dengan jq dan Parsing, rendering, dan streaming JSON besar. Untuk aturan baris NDJSON, lihat Panduan praktis file JSONL.
Disiplin pengukuran dan tiga jebakan
Pertama, kunci metodologi pencatatan waktu: dalam artikel ini setiap implementasi dijalankan tiga kali dan hasil terbaik yang dihitung (untuk menyaring getaran penjadwal), dan file dibangun penuh sebelum pengukuran dimulai. Saat mengutip angka pihak ketiga, sebutkan spesifikasi mesin — jangan pernah membandingkan 138 GB/s pada 192 inti dengan satu inti laptop Anda.
Kedua, validasi kebenaran secara silang: keempat implementasi menghitung 60.108 bintang. Percepatan apa pun yang mengubah angka telah mengubah semantik parsing (penanganan kunci duplikat, presisi bilangan bulat besar), bukan membuat lebih cepat. Samakan hasil dulu, kecepatan kemudian.
Ketiga, tiga jebakan umum: orjson.dumps() mengembalikan bytes, dan mencampurnya dengan str diam-diam menghasilkan data kotor dengan awalan b'...'; potongan pool proses harus selaras dengan batas baris — setelah f.seek(offset), buang dulu baris yang setengah; bilangan bulat besar melebihi 2^53 aman di setiap parser Python, tetapi jika hasilnya menuju sisi JavaScript, masalah presisi menunggu di sana.
FAQ
orjson atau msgspec, pilih yang mana?
Jika Anda hanya ingin loads yang lebih cepat, keduanya memberi 3× atau lebih — pilih berdasarkan aktivitas pemeliharaan dan keakraban tim. Pilih msgspec bila Anda butuh dekode parsial (msgspec.Struct + Raw), validasi tipe, atau keluaran TypedDict/dataclass; dekode deklaratifnya menambah lapisan untung independen pada array besar.
Apakah multiproses selalu lebih cepat dari satu inti?
Tidak. Pembagian, peluncuran proses, dan penggabungan punya biaya tetap, dan pada file beberapa puluh MB biasanya rugi. Tugas yang mengembalikan hasil besar (Anda butuh setiap catatan) kehilangan untung pada transfer. Sesuai aturan praktis: ganti pustaka pada satu inti dulu, dan hanya paralelkan pada skala GB untuk pekerjaan penghitungan murni.
Mengapa benchmark orjson saya tidak menunjukkan 3×?
Tiga alasan lazim: sampel terlalu kecil (waktu parsing tenggelam dalam pembacaan file dan biaya loop); hambatan sesungguhnya jaringan atau disk, bukan parsing; atau data hampir seluruhnya string panjang sehingga pembangunan objek berbobot kecil. Gunakan sampel lebih besar, bungkus hanya loop parsing dengan time.perf_counter, lalu baru simpulkan.
Bagaimana hubungan ijson dengan pustaka-pustaka ini?
ijson adalah iterator streaming: ia mengorbankan throughput demi memori konstan dan cocok untuk file jauh lebih besar daripada RAM; orjson/msgspec mengejar throughput tetapi mengubah setiap catatan menjadi objek. Keduanya tidak bertabrakan: NDJSON berskala GB selesai dengan pembacaan baris demi baris plus dekode cepat msgspec; ijson atau jq --stream hanya diperlukan untuk satu dokumen JSON raksasa.