Недавно наткнулся на любопытный образец @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× от абсолютного лидера таблицы).

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

Примечание о методологии замеров: В js-reactivity-benchmark рядом сравниваются "голые" реактивные примитивы (alien-signals, Preact Signals) и полноценные прикладные стейт-менеджеры (@pravosleva/reactive-engine, MobX, @angular/signals). Эти цифры измеряют цену реактивного слоя, а не набор возможностей: в тестах на создание тысяч пустых узлов s минималистичный примитив без DI, строковых меток и ownedEffects всегда будет быстрее, тогда как равенство в динамических графах dynamic, cellx показывает, что высокоуровневая инфраструктура не тормозит горячий путь выполнения.
Примечание о методологии замеров: В js-reactivity-benchmark рядом сравниваются "голые" реактивные примитивы (alien-signals, Preact Signals) и полноценные прикладные стейт-менеджеры (@pravosleva/reactive-engine, MobX, @angular/signals). Эти цифры измеряют цену реактивного слоя, а не набор возможностей: в тестах на создание тысяч пустых узлов s минималистичный примитив без DI, строковых меток и ownedEffects всегда будет быстрее, тогда как равенство в динамических графах dynamic, cellx показывает, что высокоуровневая инфраструктура не тормозит горячий путь выполнения.

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

В наборе тестов на семантику графа 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‑слою).

P.S.

  • В документации появился раздел Паттерны СТМ с разбором типовых кейсов (будет интересно новичкам).

  • Более подробный обзор с примерами кода на Reatom, Effector в рамках сравнения с ними (будет интересно тем, кто дочитал до конца).

UPD

Обновил описание под картинкой - но сразу скажу, картина станет нагляднее только для тех кто работал со стейт-менеджерами и понимает разницу между "стм что-то умеет" и "просто быстрый граф реактивности".

Комментарии (2)


  1. AndryVolynets
    18.11.2026 14:14

    Рекомендую, прежде чем дальше оптимизировать реализацию, отдельно исследовать историю существующих реактивных рантаймов. По этой части архитектуры вы сейчас во многом повторяете этап, который alien-signals проходил ещё в конце 2024 года.

    У Alien уже в октябре 2024 появились linked-list tracking, ordered dependency reuse и pooling Link-объектов; к ноябрю в модели были deps/depsTail и subs/subsTail. Особенно показательно, что в январе 2025 link pool оттуда вообще убрали.

    Я не утверждаю, что знаю конкретную причину его удаления. Но сам факт важен: прежде чем сегодня делать LinkPool одной из центральных оптимизаций, стоило хотя бы исследовать, почему предыдущая высокооптимизированная реализация прошла через практически тот же дизайн и затем от него отказалась. Отдельно я вообще считаю, что глобальному pool рёбер в DDG не место.

    Меня здесь, однако, больше беспокоит даже не заимствование структуры. Двусвязные списки, очевидно, никому не принадлежат, а ссылка на Linux Kernel сама по себе здесь ничего не доказывает.

    Проблема глубже: вместе с чужой реализационной моделью очень легко неосознанно унаследовать её скрытые предпосылки. Автор исходной конструкции принимал конкретные решения по конкретным причинам, но эти причины не закодированы в названиях depsTail, nextDep и prevSub. Из конечной реализации их нельзя восстановить априори.

    А затем вы начинаете цементировать тестами уже не просто representation, а весь набор неявных invariants вокруг неё.

    Alien спустя годы после появления depsTail продолжает исправлять случаи вокруг mutation/dispose во время обхода графа, unwatched nodes, удаления зависимостей, восстановления traversal state и других взаимодействий, которые из самой структуры linked list вообще не следуют.

    То есть проблема не в том, что здесь «что-то похоже на Alien». Проблема в том, что вы, похоже, независимо входите в ту же область design space с отставанием примерно на два года, но без истории решений, которая объясняет, какие варианты уже пробовали, какие выбросили и какие скрытые обязательства обнаружились только потом.


    1. mad-den Автор
      18.11.2026 14:14

      Спасибо за глубокий и предметный разбор - видно, что вы хорошо знакомы с эволюцией современных реактивных рантаймов.

      По части истории LinkPool и скрытых инвариантов вы во многом правы: у глобального пула действительно есть обратная сторона в виде продления жизни объектов до Old Space в V8 и риска retention-утечек при неполном занулении ссылок. Собственно, по следам этого обсуждения в 3.0.2 мы уже ограничили потолок пула до 2048 звеньев (~64-96 КБ), сделали безусловный сброс всех указателей при release() и дополнительно усилили защиту обхода подписчиков от синхронного dispose во время распространения сигнала. А краевые инварианты у нас закрываются прогоном reactive-framework-test-suite (159/161) для v3.0.2.

      Что касается самого сравнения с alien-signals: изначально не было задачи построить "пассажирский истребитель". Прямое сопоставление в таблице бенчмарков корректно только с оговоркой - мы измеряем цену реактивного слоя, а не функциональность библиотек. В сьюте вроде s (где в цикле создаются 1000 пустых вычислений) alien-signals всегда будет быстрее просто потому, что создаёт крошечный объект из нескольких полей без строковых меток, логгеров, валидации и метаданных владения вложенными эффектами. Требовать от полноценного стейт-менеджера такой же скорости инстанцирования - всё равно что сравнивать время разгона болида Формулы-1 без кузова (ладно, с кузовом, но без салона) и раллийного автомобиля с каркасом безопасности и запасным колесом на борту.

      На что действительно имеет смысл смотреть в этих замерах - так это на то, насколько дорого обходятся высокоуровневые фичи стейт-менеджера по сравнению с голым алгоритмом. То, что в динамических графах (dynamic, cellx) движок идёт вплотную к alien-signals (1.08x-1.17x) и обходит @angular/signals или MobX в 2-3 раза, как раз показывает, что прикладные возможности (DI, resource, валидация) не перегружают горячий путь. А выбор между примитивом вроде alien-signals и готовым стейт-менеджером на практике всё равно определяется задачами проекта, а не разницей в несколько миллисекунд на 10 000 итераций.

      P.S. Обновил описание под картинкой (не думал, что это может быть настолько неочевидно)