Архитектура Event Loop и libuv: микротаски, фазы таймеров, poll и check

Архитектурная база#

Архитектура Node.js построена на симбиозе высокопроизводительного движка исполнения JavaScript Google V8 и кроссплатформенной библиотеки асинхронного ввода-вывода libuv. Сам движок V8 однопоточен: он содержит единственный стек вызовов (Call Stack) и управляемую кучу памяти (Heap). Однако серверная платформа Node.js способна параллельно обрабатывать десятки тысяч сетевых соединений без создания отдельных потоков операционной системы на каждый запрос.

Это достигается благодаря реакторному паттерну (Reactor Pattern), реализованному внутри библиотеки libuv:

+-------------------------------------------------------------+
|                      Node.js Application                    |
|       (JavaScript Code: Business Logic, Fastify, RSC)       |
+-------------------------------------------------------------+
                              |
                              v
+-------------------------------------------------------------+
|               Node.js Core (C++ / JS Bindings)              |
|        (fs, net, http, crypto, buffer, stream, etc.)        |
+-------------------------------------------------------------+
          /                                         \
         v                                           v
+-----------------------+                 +-----------------------+
|       Google V8       |                 |         libuv         |
|  - Call Stack         |                 |  - Event Loop (6 Ph)  |
|  - Memory Heap        |                 |  - Epoll/Kqueue/IOCP  |
|  - Microtask Queue    |                 |  - Thread Pool (4-1024|
+-----------------------+                 +-----------------------+
                                                      |
                                                      v
                                   +--------------------------------------+
                                   |           OS Kernel (Syscalls)       |
                                   | Non-blocking Network / Sockets / IPC |
                                   +--------------------------------------+

libuv абстрагирует низкоуровневые интерфейсы мультиплексирования ввода-вывода конкретных операционных систем:

• epoll в Linux;
• kqueue в macOS и FreeBSD;
• IOCP (Input/Output Completion Ports) в Microsoft Windows;
• Event Ports в Solaris/illumos.

Сетевые сокеты, межпроцессные каналы (IPC) и TCP/UDP соединения обрабатываются ядром операционной системы полностью неблокирующим образом. Когда поступает входящий пакет, ядро ОС через механизм демультиплексирования пробуждает системный вызов libuv (epoll_wait / kevent / GetQueuedCompletionStatusEx) и передает зарегистрированный дескриптор файла.

Однако не все операции ввода-вывода операционные системы поддерживают в асинхронном неблокирующем режиме. В частности, операции с файловой системой (POSIX open, read, write, stat) в большинстве ОС являются блокирующими на уровне дескрипторов файлов. Для таких задач, а также для вычислительно тяжелых криптографических операций (crypto.pbkdf2, crypto.scrypt), компрессии (zlib) и разрешения DNS-имен через системный интерфейс getaddrinfo (dns.lookup), libuv содержит системный пул потоков (Thread Pool).

По умолчанию размер пула равен 4 потокам. Его емкость регулируется глобальной переменной окружения UV_THREADPOOL_SIZE (максимум до 1024 потоков), которая должна быть задана до инициализации рантайма Node.js.

Ментальная модель#

Цикл событий (Event Loop) в libuv — это бесконечный синхронный цикл на языке C, который выполняется до тех пор, пока в процессе остаются активные дескрипторы или таймеры (uv_loop_alive). Каждый полный оборот цикла называется тиком (tick).

Внутри одного тика libuv последовательно проходит через 6 строго определенных фаз:

+------------------------------------+
   |               START                |
   +------------------------------------+
                      |
                      v
   +------------------------------------+
   |   1. Timers (setTimeout/Interval)  | <--- [Microtasks drain: nextTick, Promise]
   +------------------------------------+
                      |
                      v
   +------------------------------------+
   |   2. Pending I/O Callbacks         | <--- [Microtasks drain: nextTick, Promise]
   +------------------------------------+
                      |
                      v
   +------------------------------------+
   |   3. Idle, Prepare (internal)      | <--- [Microtasks drain: nextTick, Promise]
   +------------------------------------+
                      |
                      v
   +------------------------------------+
   |   4. Poll (epoll_wait / I/O Read)  | <--- [Microtasks drain: nextTick, Promise]
   +------------------------------------+
                      |
                      v
   +------------------------------------+
   |   5. Check (setImmediate)          | <--- [Microtasks drain: nextTick, Promise]
   +------------------------------------+
                      |
                      v
   +------------------------------------+
   |   6. Close Callbacks (socket close)| <--- [Microtasks drain: nextTick, Promise]
   +------------------------------------+
                      |
                      v
   +------------------------------------+
   |  Check loop alive? (Yes -> Loop)   |
   +------------------------------------+

• Кроссплатформенная библиотека на языке C с открытым исходным кодом, обеспечивающая абстракцию над асинхронным вводом-выводом на базе циклов событий и пула системных потоков.
• Один полный последовательный проход цикла событий по всем зарегистрированным фазам libuv от Timers до Close Callbacks.
• Очередь функций обратного вызова, зарегистрированных через process.nextTick. Выполняется с наивысшим приоритетом сразу после завершения текущей JavaScript-операции до возврата в фазу libuv.
• Очередь задач стандарта ECMAScript (Promise.then/catch/finally, queueMicrotask). Выполняется сразу после опустошения nextTickQueue.
• Время задержки между моментом, когда задача должна была быть вызвана в цикле событий, и моментом фактического получения управления главным потоком.

На практике применяется#

1. Высоконагруженные API-шлюзы и Fastify/Express серверы: предотвращение зависания обработки HTTP-запросов из-за блокировок главного потока синхронными операциями JSON-парсинга или логов.
2. Мониторинг SLA и метрик задержек (Latency P95/P99): непрерывное измерение лага цикла событий через perf_hooks.monitorEventLoopDelay для триггера горизонтального автоскейлинга контейнеров в Kubernetes.
3. Оптимизация криптографии и файлового ввода-вывода: тюнинг переменной UV_THREADPOOL_SIZE в микросервисах, активно подписывающих токены JWT через асимметричные ключи или отдающих локальные файлы.
4. Кооперативная многозадачность (Cooperative Scheduling): квантование длительных вычислительных задач на итерации через setImmediate, предотвращающее блокировку фазы Poll и сохраняющее минимальный Time to First Byte (TTFB).

Как это работает#

1. Детальная анатомия шести фаз libuv#

1. Timers (Таймеры): libuv проверяет структуру двоичной кучи (min-heap) с зарегистрированными таймерами setTimeout и setInterval. Если текущее монотонное время цикла превысило пороговое значение таймера, libuv извлекает колбэк и передает управление в V8.
2. Pending Callbacks (Отложенные колбэки): фаза выполнения системных колбэков I/O, отложенных с предыдущей итерации. Например, если TCP-сокет получил сетевую ошибку операционной системы ECONNREFUSED, некоторые платформы откладывают уведомление до этой фазы.
3. Idle, Prepare: внутренние вспомогательные фазы libuv, используемые рантаймом Node.js для синхронизации внутреннего состояния перед входом в блокирующее ожидание событий.
4. Poll (Опрос демультиплексора):
   • Рассчитывается таймаут блокировки. Если очередь таймеров пуста и нет очередей setImmediate, поток переходит в ожидание событий ОС на вызове epoll_wait (или аналоге).
   • При наличии готовых файловых дескрипторов сокетов или завершенных операций пула потоков выполняются их колбэки чтения/записи.
   • Если в фазе Poll зафиксированы готовые задачи setImmediate, фаза Poll завершается немедленно, не переходя в длительное ожидание.
5. Check (Проверка): фаза предназначена исключительно для выполнения колбэков, запланированных через setImmediate(). Позволяет запустить код сразу после завершения фазы Poll текущего тика.
6. Close Callbacks (Закрытие): выполнение колбэков очистки ресурсов при вызове uv_close (например, событие socket.on('close', ...)).

2. Очереди микрозадач и семантика Node.js 11+#

До версии Node.js 11 очереди микрозадач (process.nextTick и промисы) опустошались только на границах перехода между фазами libuv. Это приводило к расхождениям со стандартом браузерного Event Loop.

Начиная с Node.js 11+ поведение было синхронизировано со спецификацией HTML5/ECMAScript: очереди микрозадач опустошаются немедленно после выполнения каждого отдельного колбэка, вне зависимости от текущей фазы libuv.

Порядок приоритета очередей микрозадач:

1. nextTickQueue (process.nextTick) — всегда имеет абсолютный приоритет.
2. microtaskQueue (Promise.then(), queueMicrotask()) — опустошается только тогда, когда очередь nextTickQueue полностью пуста.

3. Сравнение механизмов планирования асинхронных задач#

4. Архитектурный поток прохождения асинхронной операции#

5. Production-Ready мониторинг задержки Event Loop#

Для промышленной диагностики деградации цикла событий используется класс IntervalHistogram из модуля perf_hooks.

import { monitorEventLoopDelay, IntervalHistogram } from 'node:perf_hooks';
import { EventEmitter } from 'node:events';

export interface EventLoopMetrics {
  minMs: number;
  maxMs: number;
  meanMs: number;
  p50Ms: number;
  p90Ms: number;
  p99Ms: number;
  exceedsThreshold: boolean;
}

export class EventLoopMonitor extends EventEmitter {
  private histogram: IntervalHistogram | null = null;
  private timer: NodeJS.Timeout | null = null;
  private readonly resolutionMs: number;
  private readonly intervalMs: number;
  private readonly warningThresholdMs: number;

  constructor(options?: {
    resolutionMs?: number;
    intervalMs?: number;
    warningThresholdMs?: number;
  }) {
    super();
    this.resolutionMs = options?.resolutionMs ?? 10;
    this.intervalMs = options?.intervalMs ?? 1000;
    this.warningThresholdMs = options?.warningThresholdMs ?? 50;
  }

  public start(): void {
    if (this.histogram) {
      return;
    }

    // Инициализация гистограммы с дискретностью resolutionMs
    this.histogram = monitorEventLoopDelay({
      resolution: this.resolutionMs,
    });
    this.histogram.enable();

    this.timer = setInterval(() => {
      this.collectMetrics();
    }, this.intervalMs);

    // Гарантируем, что таймер мониторинга не держит процесс Node.js активным
    this.timer.unref();
  }

  public stop(): void {
    if (this.timer) {
      clearInterval(this.timer);
      this.timer = null;
    }
    if (this.histogram) {
      this.histogram.disable();
      this.histogram.reset();
      this.histogram = null;
    }
  }

  private collectMetrics(): void {
    if (!this.histogram) return;

    // monitorEventLoopDelay оперирует наносекундами (1e6 нс = 1 мс)
    const nsToMs = 1_000_000;

    const metrics: EventLoopMetrics = {
      minMs: Number((this.histogram.min / nsToMs).toFixed(2)),
      maxMs: Number((this.histogram.max / nsToMs).toFixed(2)),
      meanMs: Number((this.histogram.mean / nsToMs).toFixed(2)),
      p50Ms: Number((this.histogram.percentile(50) / nsToMs).toFixed(2)),
      p90Ms: Number((this.histogram.percentile(90) / nsToMs).toFixed(2)),
      p99Ms: Number((this.histogram.percentile(99) / nsToMs).toFixed(2)),
      exceedsThreshold: false,
    };

    metrics.exceedsThreshold = metrics.p99Ms > this.warningThresholdMs;

    this.emit('metrics', metrics);

    if (metrics.exceedsThreshold) {
      this.emit('lag-warning', {
        message: `Критический лаг Event Loop P99: ${metrics.p99Ms} мс (порог: ${this.warningThresholdMs} мс)`,
        metrics,
        timestamp: Date.now(),
      });
    }

    // Сброс гистограммы для чистоты измерений следующего интервала
    this.histogram.reset();
  }
}

6. Кооперативный батчинг с предотвращением блокировки цикла#

При обработке больших массивов данных в главном потоке Node.js необходимо разбивать синхронные итерации на неблокирующие кванты с передачей управления фазе check.

/**
 * Выполняет пакетную обработку массива данных без голодания Event Loop.
 * Между батчами управление передается через setImmediate, позволяя libuv
 * обслужить сетевой I/O в фазе Poll.
 */
export async function processInCooperativeBatches<T, R>(
  items: T[],
  batchSize: number,
  processor: (item: T) => Promise<R> | R
): Promise<R[]> {
  const results: R[] = [];
  let index = 0;

  while (index < items.length) {
    const chunk = items.slice(index, index + batchSize);
    
    // Обработка текущего кванта задач
    for (const item of chunk) {
      results.push(await processor(item));
    }

    index += batchSize;

    // Если остались элементы, уступаем управление Event Loop
    if (index < items.length) {
      await new Promise<void>((resolve) => {
        setImmediate(resolve);
      });
    }
  }

  return results;
}

Распространённые ошибки#