javascript

Обзор на ReactiveEngine v3.0 и пара слов про Интрузивные списки в JavaScript

  • среда, 18 ноября 2026 г. в 00:00:01
https://habr.com/ru/articles/1108938/

Недавно наткнулся на любопытный образец @pravosleva/reactive‑engine, релиз 3.0.0 которого вышел относительно недавно — почитал описание релиза и был несколько удивлен тому, что автор не боится экспериментировать и, сохранив обратную совместимость с публичным API (несмотря на то, что первый блин был «в коме»), полностью переписать ядро. И я решил более внимательно его изучить, попутно оглядываясь на @angular/core (которому лично я отдаю предпочтение с недавних пор) и @vue/reactivity как ориентиры современного фронтенда.

Вместе с этим, я буду опираться на:
— тесты на семантику графа https://github.com/johnsoncodehk/reactive‑framework‑test‑suite
— тесты на производительность движка https://github.com/transitive‑bullshit/js‑reactivity‑benchmark

Самое первое, что бросилось в глаза —

Интрузивные списки

Обычный (неинтрузивный) список работает так: Контейнер сам выделяет память под специальный служебный узел. Этот узел хранит указатели и копию или указатель на ваши данные.

Особенность интрузивного списка заключается в том, что указатели на следующий (и при необходимости предыдущий) элемент встраиваются непосредственно внутрь самой структуры данных. Сам объект становится узлом списка.

В нашем же случае мы имеем дело с двунаправленным интрузивным списком.

Интрузивные двунаправленные списки — Способ организации связей в графе, при котором ссылки на соседние элементы хранятся прямо внутри самих объектов рёбер.

Отойдем немного в сторону: На схеме ниже показан двунаправленный интрузивный список, устроенный по классическому принципу ядра Linux struct list_head.

Главная особенность такой схемы в том, что указатели next и prev связывают не начала самих объектов, а встроенные в них служебные структуры (хуки), образуя замкнутое кольцо.

      Голова списка (Head)
     +--------------------+

     |   struct list_head |
  +->|  [ next ]  [ prev ]|--+

  |  +---|----------------|  |
  |      |                   |
  |      v                   |
  |  Объект A (Task)         |
  |  +--------------------+  |
  |  | id: 101            |  |
  |  | name: "Worker 1"   |  |
  |  | +----------------+ |  |
  |  | | list_head hook | |  |
  |  | | [next]  [prev] | |  |
  |  | +---|-------|----+ |  |
  |  +-----|-------|------+  |
  |        |       |         |
  |        |       +---------+ (указывает на hook в Head)
  |        v
  |  Объект B (Task)
  |  +--------------------+

  |  | id: 102            |
  |  | name: "Worker 2"   |
  |  | +----------------+ |
  |  | | list_head hook | |
  |  | | [next]  [prev] | |
  |  | +---|-------|----+ |
  |  +-----|-------|------+
  |        |       |
  +--------+       +---------> (указывает на hook в Объекте A)
  (замыкается на hook в Head)

И вернемся к движку @pravosleva/reactive‑engine:

Вместо того чтобы хранить ссылки в отдельной коллекции (где память выделяется под сам объект и его внутренние бакеты), каждый объект связи сам содержит указатели next и prev.

Что это дало?

Удаление за O(1) без поиска — Чтобы отписать узел, движку не нужно искать его в Set или вычислять хэш — достаточно перекинуть ссылки.

Минимум мусора для GC состоит в следующем: При разрыве связи объект не удаляется, а обнуляется и возвращается в пул для мгновенного переиспользования.

Как мы это увидели?

В репозитории transitive‑bullshit/js‑reactivity‑benchmark преимущества удаления за O(1) и пулинга объектов (минимум мусора для GC) нагляднее всего проявляются в нагрузках (suites), где зависимости постоянно перестраиваются, а не остаются статичными:

  1. В семействе тестов dynamic постоянное переключение подписок заставляет обычные движки на Set/Map массово удалять старые записи (поиск + хэширование) и аллоцировать новые. В reactive-engine v3.0.0 разрыв связей происходит за O(1) переброской указателей, а освободившиеся NodeLink мгновенно возвращаются в LinkPool, поэтому автоматический сборщик мусора (GC) почти не срабатывает во время замера. В обзоре релиза отмечено ускорение в сьюте dynamic до 1.30× от лидера (wide dense: 681 мс против 1909 мс у Angular Signals).

  2. В тестах kairo мы видим 8 сценариев распространения сигнала по 1 000 итераций в каждом сэмпле, среди которых есть переключение зависимостей и широкое распространение broadPropagation — При частой смене ветвления (if/else) внутри computed и effect в цикле на 1 000 прогонов отписка от неактуальных сигналов происходит без деоптимизации и лишних аллокаций. Общий результат в kairo — 1.69× (broadPropagation: 683 мс против 1260 мс у Angular Signals).

  3. В тестах mol Длительный стресс‑тест на 10 000 итераций на сэмпл с условными зависимостями (conditional dependencies) и вычислениями Фибоначчи. Из‑за 10 000 циклов с условными ветками любая утечка памяти или создание временных объектов на каждом тике неизбежно вызывает паузы GC прямо внутри замеряемого интервала. Пул LinkPool удерживает аллокации в горячем цикле около нуля. Тест molBench выполняется за 811 мс (1.02× от абсолютного лидера таблицы).

Таким образом, результат прогона тестов на производительность выглядит примерно так:

Что насчет семантики графа?

В наборе тестов на семантику графа reactive‑framework‑test‑suite reactive‑engine v3.0.0 набрал 98.8% (159 из 161), наравне с @vue/reactivity 3.5.45 (правда, по разным тестам). Единственные два не пройденных кейса (#212 и #213) относятся к разделу Inner Write (запись в корневой сигнал прямо из тела эффекта, который сам же от него зависит). Примечательно, что ровно на этих же двух тестах спотыкаются и официальный полифил TC39 Signals (signal‑polyfill), и @solidjs/signals.

С точки зрения реальной продакшн‑разработки все четыре теста (#123, #141 у Vue и #212, #213 у Reactive Engine) относятся к редким граничным случаям (edge cases), а не к базовой корректности графа.

При чем здесь @angular/core?

Дело в том, что ReactiveEngine по стилю организации бизнес‑логики (классы сервисов + Dependency Injection) ближе всего к Angular, но при этом не привязывает разработчика к конкретному UI‑фреймворку и весит 7.31 КБ Gzip вместо целого фреймворка — вместо него reactive‑engine переносит привычную для Angular‑разработчиков архитектуру (сервисы на классах + DI‑контейнер) в кроссплатформенную среду — работает в чистом JS, обходя при этом по скорости распространения в бенчмарках kairo и dynamic почти в 2 раза.

Заключение

Отказ от стандартных коллекций Set и Map в пользу двунаправленных интрузивных списков и объектного пула решил главные проблемы динамических реактивных графов — лишние аллокации и работа сборщика мусора в горячих циклах. В бенчмарках это даёт предсказуемый результат: удаление связей за O(1) выводит реактивный движок в топ на сьютах с постоянным переключением зависимостей и удерживает на уровне лидеров в длительных прогонах.

При этом архитектурный фокус остался прежним: дать разработчикам компактное ядро с привычной для энтерпрайза моделью сервисов, DI‑контейнером и адаптерами под React, Vue и Angular без привязки к конкретному фреймворку (или UI‑слою).