ReactiveEngine v3.0 и интрузивные списки в JS: как отказ от Set и Map ускоряет реактивностьСтатья · дайджест за 19 ноября
ReactiveEngine v3.0 и интрузивные списки в JS: как отказ от Set и Map ускоряет реактивность
Статья4 раздела≈ 8 мин

ReactiveEngine v3.0 и интрузивные списки в JS: как отказ от Set и Map ускоряет реактивность

Пишешь обычный computed с условием if/else — скажем, экран переключается между двумя вкладками. Со стороны выглядит как мелочь. Но в наивном реактивном движке именно здесь прячется тормоз: пока граф зависимостей статичен, Set и Map летают, а стоит подпискам начать скакать на каждом тике — движок принимается гонять хэши, удалять записи и плодить мусор для сборщика мусора.

На этом и построен релиз @pravosleva/reactive-engine v3.0.0 (актуальный патч 3.0.2 от 18 ноября 2026 года, исходники на GitHub). Автор разбора на Хабре @mad-den удивился подходу разработчика: публичный API остался полностью обратно совместимым — хотя первый релиз, по его словам, был «в коме», — а всё ядро переписали с нуля. Вместо Set и Map поставили интрузивные двунаправленные списки и объектный пул. Приём из ядра Linux, но в обычном JS и весом всего 7.31 КБ gzip.

Почему Set и Map буксуют, когда подписки скачут

В основе сигналов лежит реактивный граф: сигналы (signal), вычисления (computed) и эффекты (effect) — это узлы, а подписки «кто от кого зависит» — рёбра. В лоб это делают просто: сигнал хранит Set подписчиков, а computed — Set прочитанных сигналов.

Когда ветка if/else внутри computed меняется, движок отписывается от старых зависимостей и собирает новые:

// Наивный пересчёт зависимостей на обычных Set
function recompute(node, computeFn) {
  for (const dep of node.deps) {
    // Хэш-поиск по бакетам Set на каждой отписке
    dep.subs.delete(node)
  }
  node.deps.clear()
  return computeFn()
}

На десятке узлов это незаметно. Но в горячем цикле, где ветки перекидываются тысячи раз подряд, каждое delete и add в Set считает хэш, лезет во внутренние таблицы и рождает временные объекты. Растёт GC pressure — давление на сборщик мусора. V8 (Scavenger и Mark-Sweep) начинает срабатывать прямо посреди расчётов и даёт микропаузы. Поэтому современные движки сигналов — alien-signals, Vue 3.5+, Preact Signals — постепенно ушли от Set к интрузивным спискам по мотивам struct list_head из ядра Linux.

Интрузивный список и пул LinkPool под капотом

В обычной коллекции контейнер выделяет память под отдельную обёртку вокруг данных. В интрузивном двунаправленном списке указатели prev и next живут прямо внутри самого объекта связи — без внешних бакетов и хэшей.

В src/core/core.ts у ReactiveEngine каждое ребро графа — это NodeLink. Он сразу участвует в двух списках: подписчиков сигнала (nextSubscriber / prevSubscriber) и зависимостей потребителя (nextDependency / prevDependency). Отписка работает за O(1): движок не ищет узел в Set, а просто перекидывает пару ссылок у соседей.

Дальше включается объектный пул (LinkPool). После разрыва связи NodeLink не летит в мусор: метод clear() обнуляет поля и кладёт объект в массив-пул для мгновенного повторного использования:

// Из src/core/core.ts (@pravosleva/reactive-engine v3.0.x)
export class NodeLink {
  public source: ReactiveNode | null = null
  public target: ReactiveNode | null = null
  public nextSubscriber: NodeLink | null = null
  public prevSubscriber: NodeLink | null = null
  public nextDependency: NodeLink | null = null
  public prevDependency: NodeLink | null = null
  public version: number = 0

  public clear(): void {
    this.source = null
    this.target = null
    this.nextSubscriber = null
    this.prevSubscriber = null
    this.nextDependency = null
    this.prevDependency = null
    this.version = 0
  }
}

export class LinkPool {
  private static pool: NodeLink[] = []
  private static size = 0
  // Потолок 2048 (~64–96 КБ в Old Space V8)
  private static maxPoolSize = 2048

  public static acquire(
    source: ReactiveNode,
    target: ReactiveNode
  ): NodeLink {
    if (this.size > 0) {
      this.size--
      const link = this.pool[this.size]
      this.pool[this.size] = null as unknown as NodeLink
      link.source = source
      link.target = target
      return link
    }
    const link = new NodeLink()
    link.source = source
    link.target = target
    return link
  }

  public static release(link: NodeLink): void {
    link.clear()
    if (this.size < this.maxPoolSize) {
      this.pool[this.size] = link
      this.size++
    }
  }
}

Толковая деталь здесь — жёсткий потолок maxPoolSize = 2048 (примерно 64–96 КБ в Old Space V8). Если в приложении случился разовый пик и граф раздулся, лишние звенья не застрянут в памяти навсегда — их спокойно уберёт V8 Scavenger. А в установившемся горячем цикле движок крутит одни и те же объекты с нулём новых аллокаций.

Что показали бенчмарки и тесты на честность графа

В transitive-bullshit/js-reactivity-benchmark движки сравнивают по геометрическому среднему к самому быстрому участнику набора: 1.00× — лидер, меньше — лучше.

Движокkairomoldynamiccellxs
alien-signals (3.2.1)1.00×1.03×1.00×1.10×1.02×
Preact Signals (1.14.4)1.19×1.03×1.52×1.32×1.37×
@pravosleva/reactive-engine (3.0.0)1.69×1.06×1.30×1.22×3.69×
@vue/reactivity (3.5.44)1.89×1.00×2.03×1.51×1.54×
@angular/signals (22.1.7)2.72×1.05×3.32×1.63×3.29×
SolidJS (1.9.17)3.78×1.27×4.39×1.63×3.89×
Svelte v5 (5.57.0)3.92×1.03×2.80×111.18×3.40×
MobX (7.0.6)4.41×1.28×4.37×2.54×4.90×

Картина честная. В динамических сценариях новое ядро уверенно обходит и Vue, и Angular Signals: в dynamic подписки перестраиваются без остановки, в kairo проверяется широкое распространение и смена веток if/else, а в mol длинный прогон на десять тысяч итераций с условными зависимостями сразу наказывает любой движок за паузы GC. Зато в наборе s общий индекс заметно слабее — там движок уступает и alien-signals, и Vue (хотя на точечном тесте updateComputations1000to1 вырывается вперёд).

На тяжёлых динамических прогонах разница с крупными фреймворками видна особенно ярко:

Время прогона тяжёлых динамических сценариев (меньше — лучше)

На плотной сетке wide dense и широком распространении broadPropagation переброска указателей вместо хэш-таблиц и отсутствие лишних аллокаций дают ощутимый запас по времени.

В тестах корректности графа johnsoncodehk/reactive-framework-test-suite движок прошёл 159 из 161 проверки (98.8%) — вровень с @vue/reactivity 3.5.45, у которого падают другие два кейса (#123 и #141). Оба провала ReactiveEngine (#212 и #213) относятся к редкому случаю Inner Write — записи обратно в корневой сигнал прямо из эффекта, который от него зависит. На практике это антипаттерн, и ровно на тех же двух кейсах спотыкаются официальный полифил TC39 Signals (signal-polyfill) и @solidjs/signals.

Сервисы и DI как в Angular — только без самого Angular

Почему на Хабре библиотеку сравнивали именно с @angular/core? Из-за стиля организации кода: ReactiveEngine строит бизнес-логику вокруг классов-сервисов (AbstractService) и Dependency Injection (DI) — когда сервисы не создают вручную в компонентах, а получают из общего контейнера через engine.inject(...).

import { AbstractService } from '@pravosleva/reactive-engine'
import { ReactiveEngine } from '@pravosleva/reactive-engine/react'

// Логика живёт в обычном классе и не зависит от React
class CounterService extends AbstractService {
  public counter = this.engine.signal<number>(0, 'counter:value')

  public inc = () => {
    this.counter.value += 1
  }
}

const engine = new ReactiveEngine()

export const CounterWidget = () => {
  const logic = engine.inject(CounterService)
  // Под капотом useSyncExternalStore для защиты от UI tearing
  const counter = engine.use(logic.counter)

  return (
    <button onClick={logic.inc}>
      Count: {counter}
    </button>
  )
}

У пакета лицензия MIT, ноль внешних зависимостей и адаптеры под React (^18.0.0 || ^19.2.0), Vue (>=3.2.0) и Angular (>=16.0.0). В документации на русском есть даже раздел «Паттерны СТМ» с разбором типовых задач.

При этом к зрелости стоит подходить трезво: несмотря на аккуратное ядро и тесты, комьюнити вокруг репозитория пока совсем молодое (на момент проверки у проекта было 0 звёзд на GitHub, то есть bus factor равен единице). Если приложение целиком живёт внутри Vue 3 или Angular, встроенная реактивность почти всегда проще в поддержке. А вот когда в React или чистом JS хочется аккуратных DI-сервисов с быстрым графом сигналов — или просто интересно разобрать на живом коде, как интрузивные списки работают в JS, — ReactiveEngine v3.0 точно стоит покрутить.

Хочу подробный разборГолоса помогают выбрать, что разобрать подробно. За этот материал 0 голосов.
Источники · 6