JSON 工具箱

Python 读大 JSON 提速实测:标准库、orjson 与 msgspec

结论:同一段从 NDJSON 统计 Stars 的脚本,标准库 json 要 754 毫秒,换成 msgspec 声明式解码只要 146 毫秒,多核并行还能再上一个数量级。本文用 61.4MB、30 万行样本逐级实测 stdlib、orjson、msgspec 三条路线,讲清 Python 解析大 JSON 的每一步提速从哪里来、什么时候到头。

实战约 6 分钟发布于 2026-11-15更新于 2026-11-15
Python 解析大 JSON 提速路线:标准库、orjson、msgspec 与多核并行对比示意

让 Python 解析变慢的从来不是 JSON 文本本身,而是把每个字段都变成 Python 对象的成本:换掉默认解析器、少建对象、用满多个核,同一个统计任务的吞吐能从 0.08 GB/s 提到几十 GB/s。

一、现象:同一份统计代码,速度差出一个数量级

任务很常见:一份 GitHub Events 风格的 NDJSON 日志,统计 type 为 WatchEvent 的记录里哪些仓库被 Star 最多。我在本机(Ubuntu 22.04、Python 3.12、orjson 3.13、msgspec 0.22)生成了 300,000 行、61.4MB 的样本文件,四组实现各跑三次取最优,结果如下:

实现 最优耗时 等比吞吐 相对倍数
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×

四组输出的 Star 计数完全一致(60,108 条),说明差异全部来自解析本身。第三方数据同样支持这个量级:World Programming 在 2026-11-14 发布的实测里,用 7.6GB、220 万条 GitHub Archive 事件做同一个统计,标准库写法 0.28 GB/s(约 27 秒),换 msgspec 快约 8 倍,而基于 SIMD 的 fastsimdjson 在 192 线程下 55 毫秒跑完全部数据(138 GB/s),单个文件上最高到 277 GB/s。注意其环境是 AWS c8a.metal-48xl(192 核),数字不能直接搬到普通机器,但阶梯关系是一样的。

二、标准库慢在哪

json.loads 逐行读的写法每一步都在做「完整翻译」:解析器扫过 {"id": 1, "type": "WatchEvent", ...},为这行记录新建一个 dict、7 个以上的 str 对象、若干 int,然后把这些对象的引用交给你的代码。300,000 行就是几百万个小对象分配,其中绝大部分你根本不会用到——统计任务只碰了 type 和 repo.name 两个字段。

第二个限制是 GIL。CPython 里同一时刻只有一个线程在执行 Python 字节码,就算解析 C 代码部分可以释放 GIL,你写在循环里的过滤和累加逻辑仍然串行。所以「开 8 个线程」在默认解释器上不解决任何问题,必须换思路。

三、第一级提速:换解析器

这是性价比最高的一步,改动只有 import:

import json
import orjson
import msgspec

dec = msgspec.json.Decoder()

# 三个解析器接口几乎一致,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 字节并大量使用 SIMD 指令,本机实测快 3 倍。它还有一个容易踩的 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 的对象构建,只做 token 扫描——这就是从 3.8× 到 5.2× 的差额来源。字段越多、丢弃比例越高,这一步的收益越大。

四、第二级提速:多进程切分,但收益递减

单核跑满之后,经典答案是进程池:把文件按字节范围切成 N 片(对齐到行边界),每片交给一个进程统计,最后合并 Counter。每个进程只返回一个小结果表,通信量很小,这是 map-reduce 的理想形态。

World Programming 的实测给出了这条路的形态:msgspec 进程池在 96 个进程时达到 116 GB/s,再往加进程反而变慢——调度和合并的开销吃掉了收益。还有两个现实约束:切片要对齐换行符,否则最后一行会解析失败;统计型任务(返回小结果)是进程池的最好情况,如果你要把每条记录都取出来用,进程间传输本身就会成为新瓶颈。

五、第三级提速:SIMD 与自由线程 Python

fastsimdjson 走的是另一条路:单核 8 GB/s(约为 msgspec 的 3.5 倍),因为它基于 simdjson 的结构化索引——预扫描标点确定每个 token 的位置,不建全量对象树;配合 fields=["/type", "/repo/name"] 只读取声明的 JSON Pointer 路径,回调函数拿到的只有这两个值。

它还是多线程的:配合 Python 3.14 的自由线程构建(python3.14t,PEP 703 去掉 GIL 的官方尝试),192 线程跑 7.6GB 只要 55 毫秒。在六份约 1GB 的公开基准文件上,四份超过 100 GB/s,最快的 twitter 数据集达到 277 GB/s。要注意这些是厂商口径之外的独立复测,样本是「每条记录取一两个字段」的最优场景;Deeply nested(深嵌套)文档没有这么高,其中一份只维持在 20 GB/s 附近。

六、选型速查与落地顺序

路线 机制 本机/参考吞吐 适合
json(标准库) 全量建对象,单核 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 化;统计型任务再上进程池;只有在 NDJSON 逐行取字段的场景且运行环境允许时才考虑 fastsimdjson。如果瓶颈是内存而不是速度——文件大到不能整读——方向就变了:换 ijson 流式、或者命令行侧的 jq --stream,参见用 jq 流式处理大文件 JSON与大 JSON 的解析、渲染与流式处理;NDJSON 本身的逐行读写规则见JSONL 文件实操。

七、实测口径与三个陷阱

第一,计时口径要固定:本文每个实现各跑 3 次取最优(排除调度抖动),文件在计时开始前已生成完毕;引用第三方数字时注明了机器规格,别拿 192 核的 138 GB/s 对比自己笔记本的单核数字。

第二,正确性要交叉验证:四组实现的 Star 计数都是 60,108,任何一种「提速」如果让计数变了,那是解析语义变了(重复键取值、大整数精度),不是快了。复现实验时先对齐结果再对齐速度。

第三,三个常见坑:orjson.dumps() 返回 bytes,混用 str 会静默产生 b'...' 前缀的脏数据;进程池切片必须对齐行边界,f.seek(offset) 后先丢弃半行;大整数(超过 2^53)在任何 Python 解析器里都安全,但如果结果要交给 JavaScript 侧,精度问题在另一头等你。

常见问题

orjson 和 msgspec 该选哪个?

只想加速 loads,两者都是 3 倍以上,选维护活跃度和团队熟悉度即可。需要「只解码部分字段」(msgspec.Struct + Raw)、类型校验或 TypedDict/dataclass 输出时选 msgspec,它的声明式解码在大数组上还有一层独立收益。

多进程一定比单核快吗?

不一定。切分、启动进程、合并都有固定开销,文件只有几十 MB 时往往得不偿失;返回结果大的任务(要取每条记录)传输开销会吃掉收益。经验上先单核换库,量级不够(GB 级、纯统计)再并行。

为什么我实测 orjson 没有快 3 倍?

常见原因有三个:样本太小(解析时间被读文件和循环开销淹没);瓶颈其实在网络或磁盘而不是解析;数据全是长字符串,对象构建占比低。换更大的样本、用 time.perf_counter 单独包住解析循环再下结论。

ijson 和这些库是什么关系?

ijson 是流式迭代器,牺牲吞吐换常数内存,适合文件远超内存的场景;orjson/msgspec 追求吞吐但会把整条记录建成对象。两者不冲突:GB 级 NDJSON 可以逐行读 + msgspec 快速解码,单条超大 JSON 才需要 ijson 或 jq --stream。