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

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

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

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

+-------------------------------------------------------------+
|                     Застосунок Node.js                      |
|       (JavaScript-код: бізнес-логіка, Fastify, RSC)         |
+-------------------------------------------------------------+
                              |
                              v
+-------------------------------------------------------------+
|               Ядро Node.js (C++ / JS Біндинги)              |
|        (fs, net, http, crypto, buffer, stream тощо)         |
+-------------------------------------------------------------+
          /                                         \
         v                                           v
+-----------------------+                 +-----------------------+
|       Google V8       |                 |         libuv         |
|  - Call Stack         |                 |  - Event Loop (6 Ph)  |
|  - Керування купою    |                 |  - Epoll/Kqueue/IOCP  |
|  - Microtask Queue    |                 |  - Thread Pool (4-1024|
+-----------------------+                 +-----------------------+
                                                      |
                                                      v
                                   +--------------------------------------+
                                   |           Ядро ОС (Syscalls)         |
                                   | Неблокуюча мережа / Сокети / 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)  | <--- [Злив мікротасок: nextTick, Promise]
   +------------------------------------+
                      |
                      v
   +------------------------------------+
   |   2. Pending I/O Callbacks         | <--- [Злив мікротасок: nextTick, Promise]
   +------------------------------------+
                      |
                      v
   +------------------------------------+
   |   3. Idle, Prepare (internal)      | <--- [Злив мікротасок: nextTick, Promise]
   +------------------------------------+
                      |
                      v
   +------------------------------------+
   |   4. Poll (epoll_wait / I/O Read)  | <--- [Злив мікротасок: nextTick, Promise]
   +------------------------------------+
                      |
                      v
   +------------------------------------+
   |   5. Check (setImmediate)          | <--- [Злив мікротасок: nextTick, Promise]
   +------------------------------------+
                      |
                      v
   +------------------------------------+
   |   6. Close Callbacks (socket close)| <--- [Злив мікротасок: nextTick, Promise]
   +------------------------------------+
                      |
                      v
   +------------------------------------+
   |  Перевірка loop alive? (Так -> Дія)|
   +------------------------------------+

На практиці застосовується#

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

Як це працює#

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

1. Timers: libuv перевіряє двійкову купу (min-heap) активних таймерів setTimeout та setInterval. Якщо поточний монотонний час циклу перевищив поріг таймера, libuv викликає його колбек через V8.
2. Pending Callbacks: виконання системних колбеків вводу-виводу, відкладених із попередньої ітерації (наприклад, специфічні системні помилки TCP-сокета ECONNREFUSED).
3. Idle, Prepare: внутрішні допоміжні фази libuv, що використовуються середовищем Node.js для синхронізації внутрішнього стану перед блокуючим очікуванням.
4. Poll:
   • Розраховується таймаут блокування. Якщо черга таймерів порожня і немає запланованих задач setImmediate, потік переходить у стан очікування подій ядра через системний виклик epoll_wait (або аналог).
   • За наявності готових дескрипторів сокетів або завершених задач пулу потоків виконуються їхні функції читання/запису.
   • Якщо в черзі є задачі 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: черги мікрозадач спустошуються негайно після завершення кожного окремого JavaScript-колбека, незалежно від активної фази libuv.

Пріоритет черг мікрозадач:

1. nextTickQueue (process.nextTick): завжди має абсолютний пріоритет.
2. microtaskQueue (Promise.then(), queueMicrotask()): виконується лише тоді, коли nextTickQueue повністю порожня.

3. Порівняння механізмів планування асинхронних операцій#

4. Архітектурний потік асинхронної операції#

Виробничий артефакт: Монітор затримки Event Loop#

Для діагностики стану черги подій у реальному часі використовується клас IntervalHistogram із модуля node: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;
    }

    // Ініціалізація вимірювання затримок з обраною роздільною здатністю
    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. Кооперативний батчинг для усунення зависань#

Під час обробки великих масивів даних у головному потоці необхідно розбивати синхронні цикли на кванти з передачею керування у фазу Check через setImmediate:

/**
 * Виконує пакетну обробку масиву даних без голодування 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;
}

Типові помилки#

Покроковий процес впровадження#

Питання для співбесіди та поглиблений аналіз#

Рекомендовані ресурси#