Event Loop в Node.js
Сервер на Node держит десятки тысяч соединений, но стоит одному обработчику занять поток на секунду — и ждут все. Причина в том, что вся конкурентность Node держится на одном цикле, который раздаёт время колбэкам по строгим правилам. Разберём фазы этого цикла, приоритеты очередей и то, как по метрике лага отличить нормальную нагрузку от деградации.
Содержание
- Зачем серверу знать про event loop
- Фазы event loop
- Микрозадачи и process.nextTick
- Порядок очередей: nextTick, промисы, таймеры
- Что блокирует event loop
- Голодание очередей
- Event loop lag
- Как измерять лаг
- Отличия от браузерного event loop
- Эксперименты
- Ключевые тезисы для интервью
- Заключение
- Полезные ссылки
Зачем серверу знать про event loop
Event loop — планировщик Node. Всё, что выполняется в приложении, — это колбэк, который цикл достал из очереди: обработчик запроса, колбэк таймера, продолжение await, событие сокета. Поток исполнения один, поэтому вопрос «когда выполнится мой код» всегда означает «когда до него дойдёт цикл».
Из этого следуют два практических вывода. Пропускная способность сервиса зависит от того, как быстро цикл делает итерации: каждая итерация — это пачка колбэков, а не одна задача. И любая синхронная работа внутри колбэка задерживает не только его, но и всё, что стоит за ним в очереди.
Термин «очередь задач» здесь слишком грубый. В Node несколько очередей, и они обслуживаются в разном порядке — этим объясняются и странные результаты console.log, и «внезапные» таймауты под нагрузкой. Устройство рантайма и пул потоков разобраны в статье «Node.js: как устроен рантайм»; здесь — что происходит внутри цикла.
Фазы event loop
Цикл живёт в libuv и проходит по кругу набор фаз. У каждой фазы своя очередь колбэков, которые она разбирает, прежде чем передать управление следующей.
┌────────────────┐
┌──►│ timers │ setTimeout, setInterval
│ └───────┬────────┘
│ ┌───────▼────────┐
│ │ pending │ отложенные системные колбэки
│ └───────┬────────┘
│ ┌───────▼────────┐
│ │ idle / prepare │ внутренние нужды libuv
│ └───────┬────────┘
│ ┌───────▼────────┐
│ │ poll │ ожидание и приём I/O, колбэки сокетов
│ └───────┬────────┘
│ ┌───────▼────────┐
│ │ check │ setImmediate
│ └───────┬────────┘
│ ┌───────▼────────┐
└───┤ close │ socket.on('close'), закрытие ресурсов
└────────────────┘
| Фаза | Что выполняется |
|---|---|
| timers | колбэки setTimeout и setInterval, у которых истёк срок |
| pending callbacks | колбэки системных операций, отложенные до следующей итерации |
| idle, prepare | внутренние задачи libuv, кода приложения не касаются |
| poll | ожидание готовых событий ввода-вывода и выполнение их колбэков |
| check | колбэки setImmediate |
| close callbacks | закрытие ресурсов, событие close у сокетов и потоков |
Три детали, которые чаще всего упускают.
Poll — единственная фаза, где цикл может спать. Если готовых событий нет, а таймеров и setImmediate не запланировано, цикл засыпает на системном вызове (epoll_wait, kqueue, IOCP) и не сжигает процессор. Именно поэтому простаивающий сервер почти не потребляет CPU. Если запланирован setImmediate, цикл долго спать не будет: ему нужно дойти до check.
Фаза timers не ждёт будущих таймеров. Она забирает только те, чей срок уже наступил. Сколько спать до ближайшего таймера, решает poll, и это же объясняет, почему задержка таймера — нижняя граница, а не обещание.
Между колбэками управления цикл не отдаёт. С Node 11 микрозадачи разбираются после каждого отдельного колбэка, а не только между фазами. Поэтому один длинный обработчик задерживает переход к следующей фазе целиком, даже если внутри него были await.
Микрозадачи и process.nextTick
Кроме фаз libuv, у Node есть две очереди, которые к фазам не относятся и обслуживаются раньше них.
- Очередь
process.nextTick— колбэки, добавленные черезprocess.nextTick(). - Очередь микрозадач — продолжения промисов (
then,await),queueMicrotask(), а также внутренние микрозадачи V8.
После каждого колбэка и между фазами Node сначала полностью опустошает очередь nextTick, затем так же полностью — очередь микрозадач, и только потом возвращается к циклу.
process.nextTick(() => console.log('nextTick'));
Promise.resolve().then(() => console.log('promise'));
// nextTick
// promise
Приоритет nextTick выше промисов, и это историческое решение: очередь появилась раньше нативных промисов и использовалась для внутренних нужд. Название обманчиво — это не «следующий тик таймера», а «сразу после текущей операции, до любого ввода-вывода».
Зачем nextTick вообще нужен:
- Гарантировать асинхронность. Функция, которая иногда отвечает синхронно, а иногда асинхронно, ломает порядок у вызывающего кода (эффект «Zalgo»).
nextTickделает ответ всегда асинхронным. - Завершить текущую операцию. Освободить ресурс или снять флаг после того, как текущий колбэк доработает, но до следующего I/O.
- Эмитить событие после конструктора. Чтобы слушатель успел подписаться.
В прикладном коде чаще хватает queueMicrotask() или обычного Promise.resolve().then(): они стандартные и ведут себя одинаково в браузере и в Node. nextTick оставляют для кода, которому важен приоритет выше промисов, — например, внутри библиотек.
Порядок очередей: nextTick, промисы, таймеры
Правило, которое стоит запомнить, укладывается в четыре строки:
- синхронный код до конца текущего стека;
- очередь
process.nextTickдо конца; - микрозадачи промисов до конца;
- макрозадачи через фазы event loop.
console.log('sync');
setTimeout(() => console.log('setTimeout'), 0);
setImmediate(() => console.log('setImmediate'));
Promise.resolve().then(() => console.log('promise'));
process.nextTick(() => console.log('nextTick'));
Вывод предсказуем до четвёртой строки:
sync
nextTick
promise
setImmediate ← или setTimeout: порядок не гарантирован
setTimeout
Почему последние две строки могут поменяться местами? setTimeout(fn, 0) не означает «ноль миллисекунд»: Node поднимает задержку до 1 мс. Дальше всё зависит от того, успел ли цикл дойти до фазы timers за эту миллисекунду. Если успел — сработает таймер, если нет — цикл сначала попадёт в check и выполнит setImmediate. В главном модуле порядок недетерминирован, и полагаться на него нельзя.
Другое дело — внутри I/O-колбэка:
import { readFile } from 'node:fs';
readFile(import.meta.filename, () => {
setTimeout(() => console.log('timeout'), 0);
setImmediate(() => console.log('immediate'));
});
// immediate
// timeout
Колбэк readFile выполняется в фазе poll, а следующая фаза — check с setImmediate. Таймер ждёт следующей итерации цикла, поэтому setImmediate всегда выигрывает. Это же свойство делает его удобным для «сделать после текущего I/O, но до следующего таймера».
| Инструмент | Когда выполняется | Типичное применение |
|---|---|---|
process.nextTick | сразу после текущей операции, раньше промисов | гарантировать асинхронность, внутренние библиотеки |
queueMicrotask / промисы | после nextTick, до следующей фазы | продолжения async/await, короткие отложенные действия |
setImmediate | фаза check, сразу после poll | продолжить работу после I/O |
setTimeout(fn, 0) | фаза timers, не раньше 1 мс | отложить на следующую итерацию цикла |
Что блокирует event loop
Блокировка — это когда главный поток занят синхронной работой и цикл не может перейти к следующей фазе. Внешне это выглядит как «сервис завис»: соединения принимаются ядром, но обработчики не вызываются, таймауты не срабатывают, healthcheck не отвечает.
Что блокирует чаще всего:
- синхронные версии системных вызовов:
readFileSync,scryptSync,pbkdf2Sync,gzipSync; - разбор и сериализация больших объёмов:
JSON.parseна десятки мегабайт, огромныйJSON.stringify; - тяжёлые циклы и сортировка больших массивов;
- регулярные выражения с катастрофическим бэктрекингом на пользовательском вводе;
- синхронное сжатие и хеширование в обработчике;
- ожидание в цикле (
while (Date.now() < end) {}) — худший вариант, потому что не делает вообще ничего полезного.
import { scryptSync, scrypt } from 'node:crypto';
import { promisify } from 'node:util';
const scryptAsync = promisify(scrypt);
// Плохо: главный поток занят на всё время вычисления
app.post('/login', (req, res) => {
const salt = user.salt; // соль из записи пользователя
const hash = scryptSync(req.body.password, salt, 64);
res.json({ ok: true });
});
// Лучше: вычисление уходит в пул libuv
app.post('/login', async (req, res) => {
const salt = user.salt;
const hash = await scryptAsync(req.body.password, salt, 64);
res.json({ ok: true });
});
Асинхронная версия не делает вычисление бесплатным: она занимает один из четырёх потоков пула libuv. Пятый одновременный логин встанет в очередь. Но главный поток при этом свободен и продолжает обслуживать остальные запросы — а это и есть смысл неблокирующей модели.
Что делать с CPU-bound работой:
- Взять асинхронную версию API, если она есть: она уйдёт в пул libuv.
- Вынести в
worker_threads, если вычисление долгое и постоянно. - Ограничить входные данные: лимит размера body, глубины JSON, длины строки для регулярки.
- Разбить работу на части и отдавать управление между ними, если это допустимо по смыслу.
Выбор между пулом, воркерами и отдельным сервисом — тема статьи «Worker Threads и cluster».
Голодание очередей
Блокировка — это одна длинная задача. Голодание (starvation) — это бесконечный поток коротких задач, который не даёт циклу продвинуться. Результат тот же, причина другая, и заметить её сложнее: каждая отдельная задача быстрая, а сервис всё равно не отвечает.
Классический пример — рекурсивный nextTick:
import { createServer } from 'node:http';
let ticks = 0;
function spin() {
ticks++;
process.nextTick(spin);
}
createServer((req, res) => {
res.end(String(ticks)); // не выполнится, пока spin не остановят
}).listen(3000);
spin();
Очередь nextTick опустошается целиком, прежде чем цикл вернётся к работе. Каждый вызов добавляет в неё следующий — и она никогда не заканчивается. Poll и timers не получают управления, сервер не отвечает, хотя формально ничего не «заблокировано» одним вызовом.
То же самое делает цепочка промисов:
async function spin() {
while (true) {
await Promise.resolve(); // микрозадачи крутятся, I/O не обслуживается
}
}
spin();
Здесь await создаёт иллюзию кооперативности, но продолжение — микрозадача, а микрозадачи разбираются до возврата в цикл. Поэтому await на уже разрешённом промисе не уступает управление вводу-выводу.
Разница с рекурсивным setTimeout:
function spin() {
setTimeout(spin, 0); // цикл проходит полный круг между вызовами
}
Такой код тоже грузит процессор на 100%, но между вызовами цикл успевает пройти остальные фазы, поэтому другие запросы всё-таки обслуживаются. Медленно, но обслуживаются — это принципиально другая деградация.
Практическое правило: nextTick и микрозадачи нельзя использовать для циклов и повторных попыток. Для повторов есть таймеры, для длинной работы — воркеры.
Event loop lag
Event loop lag — насколько позже запланированного срабатывает таймер. Если setTimeout(fn, 100) выполнился через 350 мс, лаг составил около 250 мс. Это прямая мера того, насколько цикл отстаёт от расписания.
Почему это важная метрика здоровья:
- Лаг растёт раньше, чем появляются ошибки. Пока цикл отстаёт на 50 мс, пользователи ещё получают ответы. Когда лаг достигает секунд, клиентские таймауты и healthcheck уже срабатывают, и сервис выпадает из балансировщика.
- Он отделяет «мы ждём» от «мы считаем». Высокая задержка запроса при низком лаге означает медленную базу или внешний сервис. Высокий лаг означает, что проблема в самом процессе.
- Он ловит неочевидные блокировки. Синхронный
JSON.parseв редкой ветке кода, тяжёлая регулярка на одном входном значении, GC-пауза — всё это видно по лагу, даже если средняя задержка в норме.
Отдельно стоит помнить про паузы сборки мусора: они останавливают исполнение JavaScript независимо от кода, и всплеск лага без изменения нагрузки часто означает именно GC. Как искать такие всплески — в статье «Производительность и память».
Лаг не заменяет остальные метрики. Он отвечает на вопрос «успевает ли процесс обслуживать то, что ему поручили», но не говорит, что именно он обслуживал. Поэтому его смотрят вместе с RPS, задержкой запросов и утилизацией CPU.
Как измерять лаг
Встроенный инструмент — monitorEventLoopDelay из node:perf_hooks. Он заводит гистограмму задержек и отдаёт перцентили.
import { monitorEventLoopDelay } from 'node:perf_hooks';
const lag = monitorEventLoopDelay({ resolution: 20 }); // мс
lag.enable();
setInterval(() => {
console.log({
p50: Math.round(lag.percentile(50) / 1e6),
p99: Math.round(lag.percentile(99) / 1e6),
max: Math.round(lag.max / 1e6),
});
lag.reset(); // окно статистики — последние 10 секунд
}, 10_000);
Значения гистограммы — в наносекундах, поэтому делим на 1e6. reset() обнуляет накопленное, чтобы метрика отражала текущее окно, а не историю с момента старта. resolution задаёт шаг измерения: чем меньше, тем точнее и дороже.
Смотреть нужно на p99 и max, а не на среднее. Средний лаг в 2 мс может скрывать регулярные всплески по 800 мс, которые и роняют запросы. Порог для алерта зависит от SLA: для API с бюджетом в 200 мс p99 лага выше 50 мс — уже повод разбираться.
Второй инструмент — eventLoopUtilization. Он показывает долю времени, которую цикл был занят, а не спал:
import { performance } from 'node:perf_hooks';
let prev = performance.eventLoopUtilization();
setInterval(() => {
const current = performance.eventLoopUtilization();
const delta = performance.eventLoopUtilization(current, prev);
console.log(`event loop занят: ${(delta.utilization * 100).toFixed(1)}%`);
prev = current;
}, 5_000);
Комбинация двух метрик читается так:
| Лаг | Утилизация | Что происходит |
|---|---|---|
| низкий | низкая | сервис простаивает, ждёт запросов |
| низкий | высокая | нормальная нагрузка: цикл занят полезной работой и успевает |
| высокий | высокая | цикл перегружен или заблокирован синхронным кодом |
| высокий | низкая | всплески: GC-паузы, редкие тяжёлые операции, троттлинг CPU в контейнере |
В проде эти числа отдают в систему метрик. Если используется prom-client, collectDefaultMetrics() уже собирает nodejs_eventloop_lag_seconds по перцентилям — отдельный код не нужен. Как связать метрику с логами и трейсами — в статье «Логирование и наблюдаемость».
Самый простой способ увидеть лаг без инструментов — измерять дрейф таймера:
import { performance } from 'node:perf_hooks';
let last = performance.now();
setInterval(() => {
const now = performance.now();
console.log(`лаг: ${Math.round(now - last - 1000)} мс`);
last = now;
}, 1000);
На здоровом процессе цифры будут в районе единиц миллисекунд, на заблокированном — сотен и тысяч.
Отличия от браузерного event loop
Модель похожа: есть стек вызовов, макрозадачи и микрозадачи, а микрозадачи разбираются после каждой макрозадачи. Но драйвер цикла разный.
| Аспект | Браузер | Node.js |
|---|---|---|
| Что двигает цикл | рендеринг, события, таймеры | готовность ввода-вывода в libuv |
| Макрозадачи | таймеры, события, MessageChannel | фазы libuv: timers, poll, check, close |
setImmediate | нет | фаза check |
process.nextTick | нет | очередь с приоритетом выше промисов |
| Микрозадачи | Promise, queueMicrotask, MutationObserver | Promise, queueMicrotask |
| Анимация | requestAnimationFrame | нет |
| Минимальная задержка таймера | около 4 мс, троттлинг в фоне | 1 мс |
| Завершение | вкладка закрывается пользователем | процесс выходит, когда цикл пуст |
Ключевое следствие: в браузере цикл обязан успевать отрисовать кадр, поэтому долгая задача портит анимацию и отзывчивость интерфейса. В Node рендеринга нет, зато есть обязательства перед соединениями и таймерами — блокировка выглядит как зависший API, а не как подтормаживающий скролл.
Ещё одно отличие — время жизни. Браузерная вкладка живёт, пока её не закроют. Процесс Node завершается, когда в цикле не остаётся работы: незакрытые сокеты, таймеры и активные запросы держат его живым, а unref() снимает этот учёт. Поэтому сервер с открытым портом не завершается никогда, а CLI-скрипт выходит сразу после последнего колбэка.
Базовая модель Event Loop в языке разобрана в статье «Цикл событий и стек вызовов».
Эксперименты
Три запускаемых опыта, которые переводят теорию в наблюдения.
1. Порядок очередей
console.log('sync');
setTimeout(() => console.log('timeout'), 0);
setImmediate(() => console.log('immediate'));
Promise.resolve().then(() => console.log('promise'));
process.nextTick(() => console.log('nextTick'));
Запустите файл несколько раз: sync, nextTick, promise всегда на своих местах, а timeout и immediate могут меняться местами. Это и есть недетерминированность, о которой предупреждают на собеседованиях.
2. Лаг под блокировкой
import { performance } from 'node:perf_hooks';
let last = performance.now();
setInterval(() => {
const now = performance.now();
console.log(`лаг: ${Math.round(now - last - 100)} мс`);
last = now;
}, 100);
// блокируем главный поток на 2 секунды
const end = Date.now() + 2000;
while (Date.now() < end) {}
Пока крутится while, тиков нет. После выхода появится один тик с лагом около 1900 мс — это и есть остановка цикла. Если заменить while на асинхронный await sleep(2000), лаг останется нулевым: ожидание не занимает главный поток.
3. Голодание против блокировки
// Вариант А: голодание — сервис не отвечает, хотя задач много и они короткие
function tick() {
process.nextTick(tick);
}
tick();
// Вариант Б: блокировка — одна длинная задача
const end = Date.now() + 60_000;
while (Date.now() < end) {}
Оба варианта дают одинаковый внешний симптом, но лечатся по-разному: в первом нужно убрать рекурсию в микрозадачах, во втором — вынести работу из главного потока.
Ключевые тезисы для интервью
- Event loop — не одна очередь, а цикл libuv из фаз (timers → pending → poll → check → close); порядок колбэка задаёт фаза, а не момент его постановки.
- После каждого колбэка Node полностью опустошает очередь
process.nextTick, затем микрозадачи; поэтомуnextTickи промисы всегда раньше таймеров и ввода-вывода. setTimeout(fn, 0)даёт нижнюю границу в 1 мс и проход через фазу timers: в главном модуле его порядок сsetImmediateнедетерминирован, а внутри I/O-колбэкаsetImmediateвсегда первый.- Синхронная работа блокирует весь сервис: пока стек занят, цикл не переходит к следующей фазе, поэтому CPU-bound уходит в пул libuv или в
worker_threads. - Рекурсивные
nextTickи промисы голодают цикл: их очереди разбираются до конца, и poll с timers не получают управления, хотя каждая задача быстрая. - Event loop lag — ранний признак деградации: он растёт до появления таймаутов; измеряется гистограммой
monitorEventLoopDelayи дополняетсяeventLoopUtilization. - Браузерный и Node-цикл совпадают в семантике микрозадач, но различаются источниками макрозадач: рендеринг и
requestAnimationFrameпротив фаз libuv и готовности ввода-вывода.
Заключение
Event loop превращает один поток JavaScript в конкурентный сервер, но платит за это строгой дисциплиной: любая синхронная работа останавливает всё, а очереди nextTick и микрозадач могут голодать цикл, даже если каждая задача короткая. Понимание фаз объясняет, почему setImmediate обгоняет таймер внутри I/O-колбэка, почему setTimeout(fn, 0) не равен нулю и почему await не всегда уступает управление. Метрика лага делает эти процессы наблюдаемыми: она растёт раньше, чем пользователи видят ошибки, и отличает перегрузку собственного процесса от медленной зависимости. Дальше остаётся выбрать правильный инструмент под характер работы — пул libuv для системных вызовов, воркеры для вычислений, таймеры для отложенных повторов.
Полезные ссылки
- The Node.js Event Loop — официальный разбор фаз и
nextTick - libuv: design overview — как устроен цикл на уровне библиотеки
- Don’t Block the Event Loop — практические рекомендации
- perf_hooks —
monitorEventLoopDelay,eventLoopUtilization,performance - Цикл событий и стек вызовов — базовая модель Event Loop в JavaScript