JSON Toolkit

Быстрое чтение больших JSON в Python: практический бенчмарк stdlib, orjson и msgspec

Главное: Тот же скрипт подсчёта Stars из NDJSON работает 754 мс со стандартной библиотекой json и всего 146 мс с декларативным декодированием msgspec, а многоядерный параллелизм добавляет ещё один порядок. В статье поэтапно протестированы stdlib, orjson и msgspec на выборке 61,4 МБ и 300 000 строк — и объяснено, откуда берётся каждое ускорение и когда оно исчерпывается.

Продвинутый~6 мин чтенияОпубликовано 2026-11-15Обновлено 2026-11-15
Сравнение путей ускорения парсинга больших JSON в Python: stdlib, orjson, msgspec и многоядерный параллелизм

Замедляют парсинг в Python не сами JSON-тексты, а стоимость превращения каждого поля в объект Python. Смените парсер по умолчанию, стройте меньше объектов, задействуйте все ядра — и та же задача подсчёта вырастет с 0,08 GB/s до десятков GB/s.

Наблюдение: тот же код, разница в порядок величины

Задача классическая: в логе NDJSON в стиле GitHub Events подсчитать, какие репозитории чаще всего получают звёзды среди записей, где type равен WatchEvent. На моей машине (Ubuntu 22.04, Python 3.12, orjson 3.13, msgspec 0.22) я сгенерировал файл-выборку на 61,4 МБ и 300 000 строк и прогнал четыре реализации по три раза, взяв лучший результат:

Реализация Лучшее время Приведённая пропускная способность Относительно
json.loads построчно 754 мс 0,08 GB/s 1× (база)
orjson.loads построчно 248 мс 0,24 GB/s 3,0×
msgspec декодирование в dict 201 мс 0,30 GB/s 3,8×
msgspec декларативный Struct 146 мс 0,41 GB/s 5,2×

Все четыре реализации выдали ровно одинаковые счётчики звёзд (60 108 записей), значит вся разница — от самого парсинга. Сторонние данные подтверждают тот же порядок: в тесте, опубликованном World Programming 2026-11-14, та же статистика по 7,6 ГБ и 2,2 миллионам событий GitHub Archive шла со скоростью 0,28 GB/s на стандартной библиотеке (около 27 секунд), примерно в 8 раз быстрее с msgspec, а SIMD-ориентированный fastsimdjson обработал весь набор за 55 мс на 192 потоках (138 GB/s), достигнув пика 277 GB/s на одном файле. Учтите: их машина — AWS c8a.metal-48xl со 192 ядрами, поэтому числа напрямую не переносятся на ноутбук — но форма лестницы та же.

Где стандартная библиотека теряет время

Подход json.loads построчно делает «полный перевод» на каждом шаге: парсер сканирует {"id": 1, "type": "WatchEvent", ...}, создаёт новый dict, минимум семь объектов str и несколько int для одной записи, а затем передаёт ссылки вашему коду. Триста тысяч строк означают миллионы мелких выделений объектов, большинство из которых вы никогда не трогаете — задача подсчёта читает лишь два поля, type и repo.name.

Второе ограничение — GIL. В CPython лишь один поток в каждый момент исполняет байткод Python, и даже если C-код парсера отпускает GIL, ваша логика фильтрации и накопления внутри цикла остаётся последовательной. Восемь потоков на интерпретаторе по умолчанию не решают ничего; нужна другая стратегия.

Первый уровень ускорения: смените парсер

Это шаг с лучшим соотношением усилий и результата — меняется только 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-инструкции; на моей машине он был в три раза быстрее. Есть одна ловушка 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, 240 000 строк без WatchEvent полностью пропускают построение объекта repo и лишь сканируют токены — именно отсюда скачок с 3,8× до 5,2×. Чем больше полей у записи и чем выше доля отброшенных, тем больше выгода этого шага.

Второй уровень: распределение между процессами с убывающей отдачей

Когда одно ядро исчерпано, классический ответ — пул процессов: файл делится на N диапазонов байтов (выровненных по границам строк), каждый кусок получает отдельный процесс-воркер, а в конце Counters объединяются. Каждый процесс возвращает лишь маленькую таблицу результатов, поэтому расходы на обмен минимальны — идеальная форма map-reduce.

Тест World Programming показывает, как выглядит этот путь: пул процессов msgspec достиг пика 116 GB/s на 96 процессах, а добавление ещё процессов делало его медленнее — накладные расходы планирования и слияния съедали выигрыш. Есть два практических ограничения: куски должны быть выровнены по символам перевода строки, иначе последняя строка каждого куска не разберётся; и задачи подсчёта (возвращающие малые результаты) — лучший случай для пула процессов. Если нужно вытащить и использовать каждую запись, сама передача между процессами становится новым узким местом.

Третий уровень: SIMD и Python без GIL

fastsimdjson идёт другой дорогой: 8 GB/s на одном ядре (примерно в 3,5 раза быстрее msgspec), потому что он опирается на структурное индексирование simdjson — заранее сканирует знаки препинания, чтобы определить позицию каждого токена, не строя полного дерева объектов; в сочетании с fields=["/type", "/repo/name"] он читает только объявленные пути JSON Pointer, и колбэк получает лишь эти два значения.

Он также многопоточный: в паре со свободнопоточным сборком Python 3.14 (python3.14t, официальная попытка PEP 703 убрать GIL) 192 потока обработали 7,6 ГБ за 55 мс. На шести публичных тестовых файлах примерно по 1 ГБ четыре превысили 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
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 и Парсинг, рендеринг и потоковая обработка больших JSON. О построчных правилах NDJSON читайте в Справочнике по файлам JSONL.

Дисциплина измерений и три ловушки

Во-первых, зафиксируйте методику хронометража: в этой статье каждая реализация запускается трижды, берётся лучший результат (чтобы отсеять дрожание планировщика), а файл полностью сгенерирован до начала измерения. Цитируя сторонние числа, указывайте спецификацию машины — никогда не сравнивайте 138 GB/s на 192 ядрах с одним ядром своего ноутбука.

Во-вторых, перекрёстно проверяйте корректность: все четыре реализации насчитали 60 108 звёзд. Любое «ускорение», меняющее счётчик, изменило семантику парсинга (обработка дубликатов ключей, точность больших целых), а не сделало быстрее. Сначала сверьте результаты, потом скорости.

В-третьих, три типичные ловушки: orjson.dumps() возвращает bytes, и смешивание со str молча создаёт грязные данные с префиксом b'...'; куски пула процессов должны быть выровнены по границам строк — после f.seek(offset) сначала отбросьте неполную строку; большие целые свыше 2^53 безопасны в любом парсере Python, но если результат уходит на сторону JavaScript, проблема точности ждёт уже там.

FAQ

Что выбрать: orjson или msgspec?

Если нужен только более быстрый loads, оба дают 3× и больше — выбирайте по активности поддержки и привычкам команды. Выбирайте msgspec, когда нужно частичное декодирование (msgspec.Struct + Raw), проверка типов или вывод в TypedDict/dataclass; его декларативное декодирование добавляет отдельный слой выгоды на больших массивах.

Многопроцессность всегда быстрее одного ядра?

Нет. Разделение, запуск процессов и слияние имеют фиксированные расходы, и с файлом в несколько десятков МБ это обычно убыток. Задачи с большими результатами (нужна каждая запись) теряют выигрыш на передаче. По практическому правилу: сначала смените библиотеку на одном ядре, и распараллеливайте только на масштабе ГБ в чистых задачах подсчёта.

Почему мой тест orjson не показывает 3×?

Три обычные причины: выборка слишком мала (время парсинга тонет в чтении файла и накладных расходах цикла); настоящее узкое место — сеть или диск, а не парсинг; либо данные почти целиком из длинных строк, так что доля создания объектов мала. Возьмите большую выборку, оберните только цикл парсинга в time.perf_counter и лишь потом делайте выводы.

Как ijson связан с этими библиотеками?

ijson — потоковый итератор: он жертвует пропускной способностью ради постоянной памяти и подходит файлам, намного превышающим RAM; orjson/msgspec гонятся за пропускной способностью, но превращают каждую запись в объекты. Они не конфликтуют: NDJSON в масштабе ГБ решается построчным чтением и быстрым декодированием msgspec; ijson или jq --stream нужны лишь одному огромному JSON-документу.