100 000 actualizaciones por segundo en React: WebSocket, Web Workers y un store propioArtículo · digest del 25 de octubre
Esquema tridimensional de un flujo de datos de alto rendimiento en React con Web Worker, búfer Zero-Copy y store mutable a 100 000 actualizaciones por segundo.
Artículo4 secciones≈ 7 min

100 000 actualizaciones por segundo en React: WebSocket, Web Workers y un store propio

Imagina un escenario clásico de fintech o monitorización en tiempo real: en el navegador hay una tabla abierta con 100 000 filas. Por WebSocket llegan cotizaciones sin descanso desde el servidor — lotes de 5 000 deltas cada 50 milisegundos. En total, 100 000 actualizaciones de campos por segundo. Y mientras tanto, la interfaz tiene que seguir respondiendo como la seda: scroll fluido a 60 FPS, clics instantáneos y cero congelamientos.

Si intentas resolver esto con las herramientas habituales de React —meter los datos en useState, conectar Redux Toolkit con Immer o usar Zustand—, la pestaña del navegador se quedará colgada en seco durante el primer segundo tras abrir la conexión.

En un análisis práctico publicado en Habr, el autor rusaleffa disecciona por qué colapsa al instante la gestión de estado convencional y muestra cómo una arquitectura en tres capas con Web Workers salva el rendimiento de la interfaz.

Anatomía del colapso: por qué useState y Redux ahogan el hilo principal del navegador

En el navegador, JavaScript se ejecuta en un único hilo principal (Main Thread). Ese hilo reparte el tiempo de CPU entre ejecutar código, calcular estilos y pintar fotogramas (con un presupuesto de 16.6 ms por fotograma para mantener 60 FPS).

Cuando al hilo principal le cae un lote de 5 000 objetos JSON, ocurren tres desastres a la vez:

  1. Bloqueo por parseo: analizar un JSON de texto de ese tamaño con JSON.parse tarda entre 30 y 70 ms, congelando la interfaz por completo.
  2. Pausas del recolector de basura: Redux y React exigen crear copias nuevas de los objetos en cada cambio ({ ...item, price }). Reservar 100 000 objetos por segundo satura el heap y obliga al Garbage Collector a lanzar ciclos de Major GC que paran el hilo cientos de milisegundos.
  3. Re-renderizado en cascada: tocar el estado global fuerza a React a comparar el árbol del DOM virtual a través de miles de selectores.

Protocolo binario y traslado del parseo de red a un Web Worker dedicado

El primer paso es sacar toda la rutina de red y el parseo fuera del hilo principal, abriendo el WebSocket dentro de un hilo en segundo plano: un Dedicated Web Worker.

El segundo paso es abandonar el JSON en texto plano y pasar a un empaquetado binario con ArrayBuffer y DataView. Cada delta cabe en apenas 16 bytes: 4 bytes para id, 8 bytes para price y 4 bytes para volume. El tráfico de red se reduce entre 3 y 4 veces.

El worker recibe el flujo binario y reenvía el búfer al hilo principal:

// worker.js - hilo en segundo plano para procesar telemetría
let socket = null;

self.onmessage = (event) => {
  if (event.data.type === 'CONNECT') {
    socket = new WebSocket(event.data.url);
    socket.binaryType = 'arraybuffer';

    socket.onmessage = (event) => {
      if (event.data instanceof ArrayBuffer) {
        // Transferimos el búfer al Main Thread con Zero-Copy (Transferable Objects)
        // La memoria no se copia: se transfiere la propiedad del puntero
        self.postMessage({ type: 'BATCH_UPDATE', buffer: event.data }, [event.data]);
      }
    };
  }
};

El segundo argumento [event.data] en postMessage activa los Transferable Objects: el navegador no clona los bytes, sino que cede al instante la propiedad de ese bloque de memoria del worker al hilo principal en tiempo cero (Zero-Copy).

Zero-Copy con Transferable Objects y un store mutable fuera del árbol de React

En el hilo principal renunciamos a fabricar copias inmutables. Las 100 000 filas viven en un Map nativo de JavaScript fuera del contexto de React.

Las actualizaciones se aplican directamente en sitio (In-Place Mutation) incrementando el número de versión de la fila:

// store.ts - almacén de alto rendimiento fuera del árbol de componentes
export interface DataItem {
  id: number;
  price: number;
  volume: number;
  version: number;
}

type Subscriber = (version: number) => void;

export class LiveDataStore {
  private data = new Map<number, DataItem>();
  private subscribers = new Map<number, Set<Subscriber>>();
  private pendingUpdates = new Set<number>();
  private rafScheduled = false;

  public applyBinaryBuffer(buffer: ArrayBuffer) {
    const view = new DataView(buffer);
    const count = view.byteLength / 16;

    for (let i = 0; i < count; i++) {
      const offset = i * 16;
      const id = view.getInt32(offset, true);
      const price = view.getFloat64(offset + 4, true);
      const volume = view.getInt32(offset + 12, true);

      const entity = this.data.get(id);
      if (entity) {
        entity.price = price;
        entity.volume = volume;
        entity.version++;
        this.pendingUpdates.add(id);
      }
    }

    this.scheduleBatchFlush();
  }

  private scheduleBatchFlush() {
    if (this.rafScheduled) return;
    this.rafScheduled = true;

    requestAnimationFrame(() => {
      this.pendingUpdates.forEach((id) => {
        const entity = this.data.get(id);
        const subs = this.subscribers.get(id);
        if (entity && subs) {
          subs.forEach((cb) => cb(entity.version));
        }
      });
      this.pendingUpdates.clear();
      this.rafScheduled = false;
    });
  }

  public subscribe(id: number, cb: Subscriber) {
    if (!this.subscribers.has(id)) {
      this.subscribers.set(id, new Set());
    }
    this.subscribers.get(id)!.add(cb);
    return () => this.subscribers.get(id)?.delete(cb);
  }
}
Agrupación de cambios con requestAnimationFrame

Nunca dispares un renderizado por cada paquete de red que entra. Acumula los deltas en una cola y vuelca los cambios exactamente una vez por fotograma mediante requestAnimationFrame.

Sincronización con requestAnimationFrame y virtualización de filas

En pantalla, gracias a un virtualizador, solo se montan las 30–50 filas de la tabla que están visibles en el monitor en ese momento.

Cada componente de fila se suscribe mediante useSyncExternalStore únicamente a su propio id. Cuando en el store muta la fila 42, solo recibe la notificación su componente correspondiente, que actualiza dos cifras en pantalla. El resto de filas ni se inmutan.

El resultado es espectacular: el Web Worker en segundo plano absorbe el tráfico del socket en otro núcleo, el store mutable elimina las pausas del recolector de basura y React sostiene sin esfuerzo los 60 FPS bajo un torrente de 100 000 actualizaciones por segundo.

Quiero un análisis detalladoLos votos ayudan a elegir qué analizar a fondo. Este material tiene 0 votos.
Fuentes · 2