Навигация

Node.js: как устроен рантайм

Почти каждый современный бэкенд на JavaScript начинается с node app.js, но за этой командой стоят три независимые части: движок V8, библиотека libuv и привязки к операционной системе. Понимание того, что именно исполняет код и где он ждёт ввод-вывод, объясняет и «магическую» скорость на I/O, и внезапные зависания сервиса под нагрузкой. В этой статье разберём устройство рантайма и границы, за которыми однопоточная модель перестаёт быть преимуществом.

Содержание

  1. Что такое Node.js
  2. V8: движок JavaScript
  3. libuv: event loop и пул потоков
  4. Где проходит граница V8 и libuv
  5. Один поток выполнения
  6. Пул libuv: что уходит в фоновые потоки
  7. Неблокирующий ввод-вывод
  8. Миф о single-threaded
  9. global, globalThis и process
  10. Отличия от браузерного рантайма
  11. Когда Node.js уместен
  12. Когда Node.js не подходит
  13. Эксперименты, которые объясняют рантайм
  14. Ключевые тезисы для интервью
  15. Заключение
  16. Полезные ссылки

Что такое Node.js

Node.js — это среда исполнения (рантайм) для JavaScript вне браузера. В неё входят:

  • V8 — движок JavaScript, тот же, что в Chrome: парсинг, компиляция, исполнение, управление памятью.
  • libuv — C-библиотека, которая даёт event loop, асинхронный доступ к файлам, сети, DNS и пул потоков.
  • Стандартная библиотека node:* — модули fs, net, http, crypto, stream и другие.
  • Привязки к системным библиотекам — OpenSSL для TLS и криптографии, zlib для сжатия, llhttp для разбора HTTP, c-ares для DNS.
  • N-API — стабильный интерфейс для нативных аддонов на C/C++.

Node.js — не язык и не фреймворк. Язык — JavaScript (плюс TypeScript через сборку), фреймворки вроде Express и Fastify живут поверх рантайма. Рантайм определяет, какие API доступны и как выполняется код.

Актуальные LTS-версии на момент написания — Node 24 и Node 26; всё описанное ниже относится к обеим.


V8: движок JavaScript

V8 отвечает за всё, что происходит внутри одного потока исполнения JavaScript.

Как код превращается в машинный

  1. Исходник разбирается в AST.
  2. Ignition компилирует AST в байткод и исполняет его.
  3. Горячие функции компилируются оптимизирующими компиляторами (Sparkplug, Maglev, Turbofan) уже в машинный код.
  4. Если предположения оптимизации нарушились (например, изменился тип свойства), функция деоптимизируется обратно в байткод.

Отсюда практическое правило: однородные типы и стабильные формы объектов работают быстрее, чем постоянно меняющиеся. Цикл, где в массив кладут то число, то строку, теряет оптимизацию.

Память и сборка мусора

V8 делит кучу на молодое и старое поколение:

  • Scavenger быстро собирает молодое поколение, где живёт большинство короткоживущих объектов.
  • Mark-Compact обрабатывает старое поколение: помечает достижимые объекты и уплотняет память.

Сборка мусора останавливает исполнение JavaScript (stop-the-world), хотя современные алгоритмы делают паузы короткими и инкрементальными. Размер кучи ограничен и настраивается флагом --max-old-space-size. Если приложение упирается в лимит, процесс падает с JavaScript heap out of memory, а не «тормозит» — подробнее о памяти и утечках в разделе Память и производительность.

Чего V8 не делает

V8 не умеет читать файлы, открывать сокеты и узнавать время. Он умеет только исполнять JavaScript и вызывать функции, которые ему передали снаружи. Всё системное — работа libuv и модулей Node.


libuv: event loop и пул потоков

libuv — слой между Node и операционной системой. Она решает три задачи.

1. Event loop

Event loop — бесконечный цикл, который забирает готовые события и вызывает соответствующие колбэки. Внутри него есть фазы: таймеры, отложенные колбэки, poll (ожидание I/O), check (setImmediate), close-колбэки. Пока в очереди есть работа, цикл крутится; когда работы нет — засыпает на системном вызове ожидания (epoll на Linux, kqueue на macOS, IOCP на Windows), не сжигая CPU.

Подробный разбор фаз, process.nextTick и микрозадач — в отдельной статье раздела; базовый механизм для браузера разобран в Цикл событий и стек вызовов.

2. Абстракция над ОС

Один и тот же код net.createServer() работает на Linux, macOS и Windows, хотя механизмы готовности дескрипторов у них разные. libuv прячет эту разницу и приводит таймеры, сигналы, сокеты, пайпы и дочерние процессы к единому API.

3. Пул потоков

Не всякую операцию можно сделать неблокирующей на уровне ОС. Для файлов и части криптографии libuv держит пул из 4 потоков по умолчанию — они выполняют работу, пока главный поток продолжает крутить event loop.

Размер пула задаётся переменной окружения UV_THREADPOOL_SIZE (до 1024) и читается один раз при старте процесса.


Где проходит граница V8 и libuv

Полезно держать в голове простую схему:

ваш код (JavaScript)
      │
      ├── V8: исполнение, типы, память, GC
      │
      └── node:* модули (JS + C++)
                │
                ├── libuv ──► event loop, пул потоков, сокеты
                ├── OpenSSL ─► crypto, tls
                └── zlib ────► сжатие

Практический смысл границы такой: всё, что вы написали на JavaScript, выполняется в одном потоке и последовательно. Асинхронным может быть только вызов, который уходит за пределы V8 — в libuv или в системную библиотеку, — и возвращается колбэком (или резолвом промиса) обратно в главный поток.


Один поток выполнения

Node исполняет JavaScript в одном потоке. Это значит:

  • два обработчика запросов никогда не выполняются одновременно;
  • глобальные переменные и модульные состояния не требуют блокировок;
  • console.log из разных запросов не перемешается внутри одной синхронной операции;
  • любая долгая синхронная работа останавливает всё: таймеры, приём соединений, отправку ответов.

Последний пункт — источник большинства проблем. Асинхронный код не делает вычисления параллельными, он лишь позволяет не ждать ввод-вывод.

// Плохо: 2 секунды сервис не отвечает никому
app.get('/report', (req, res) => {
  const end = Date.now() + 2000;
  while (Date.now() < end) {} // имитация тяжёлого расчёта
  res.json({ ok: true });
});

// Хорошо для I/O: пока читается файл, обслуживаются другие запросы
app.get('/report', async (req, res) => {
  const data = await fs.readFile('./report.json', 'utf8');
  res.type('json').send(data);
});

Во втором примере время уходит на ожидание диска, а не на процессор, поэтому главный поток свободен. В первом — занят целиком.


Пул libuv: что уходит в фоновые потоки

Не все асинхронные операции одинаковы. Часть из них вообще не занимает поток, пока ждёт, а часть выполняется в пуле.

ОперацияКто выполняетЗанимает поток пула
net, http, dgram (сокеты)ОС через event loopНет
fs.readFile, fs.writeFile, fs.statlibuv, пулДа
dns.lookup (getaddrinfo)libuv, пулДа
crypto.pbkdf2, scrypt, randomBytesOpenSSL в пулеДа
zlib.gzip (асинхронный)libuv, пулДа
setTimeout, setImmediateevent loopНет
Promise, process.nextTickV8, главный потокНет

Ключевой вывод: сетевые запросы масштабируются десятками тысяч соединений, а файловые и криптографические операции — четырьмя потоками. Пять одновременных pbkdf2 уже образуют очередь.

Отдельно запомните разницу между DNS-функциями: dns.lookup идёт через системный resolver в пуле и учитывает /etc/hosts, а dns.resolve* работает через c-ares и обращается к DNS-серверам напрямую.

import { pbkdf2 } from 'node:crypto';
import { performance } from 'node:perf_hooks';

const start = performance.now();

for (let i = 0; i < 8; i++) {
  pbkdf2('password', `salt-${i}`, 600_000, 64, 'sha512', () => {
    const elapsed = Math.round(performance.now() - start);
    console.log(`хеш #${i} готов через ${elapsed} мс`);
  });
}

Запустите файл как есть и с UV_THREADPOOL_SIZE=2 node file.js — во втором случае результаты пойдут парами: два потока, две задачи одновременно. При четырёх потоках по умолчанию — четвёрками.

Синхронные версии тех же функций (pbkdf2Sync, readFileSync) не идут в пул вообще: они блокируют главный поток до завершения. Их место — старт приложения и CLI-скрипты, но не обработчики запросов.


Неблокирующий ввод-вывод

Идея неблокирующего I/O в том, что поток не простаивает, пока данные едут по сети или читаются с диска.

  1. Код вызывает socket.read() или fs.readFile().
  2. Работа передаётся ОС (или пулу потоков) и регистрируется в event loop.
  3. Главный поток возвращается к другим задачам.
  4. Когда данные готовы, ОС сообщает об этом через poll-фазу, срабатывает колбэк.
  5. Колбэк снова выполняется в главном потоке.

Время ожидания не оплачивается процессором. Поэтому один процесс Node держит десятки тысяч открытых соединений: каждое стоит памяти на сокет и буферы, но не отдельного потока.

Именно на этом строится сравнение с моделью «поток на соединение»: там 10 000 соединений — это 10 000 потоков и переключения контекста, здесь — один цикл и набор дескрипторов. Ограничениями становятся файловые дескрипторы ОС, память под буферы и пропускная способность, а не потоки.


Миф о single-threaded

Фраза «Node.js однопоточный» верна только для исполнения JavaScript. В реальном процессе потоков несколько:

  • главный поток — event loop и весь JavaScript;
  • 4 потока пула libuv — файлы, DNS lookup, криптография, zlib;
  • служебные потоки V8 — фоновая компиляция и параллельная сборка мусора;
  • потоки ОС и платформы — обработка сигналов, внутренние нужды;
  • worker_threads — потоки, которые вы создаёте сами, каждый со своим изолированным V8-контекстом.

Правильная формулировка: один поток исполнения JavaScript, но многопоточный процесс. Из неё следуют два вывода, которые часто путают:

  • общих данных в JS-коде нет, поэтому гонки в привычном виде отсутствуют;
  • но и распараллелить вычисления «бесплатно» нельзя — для этого нужны worker threads или отдельные процессы.

global, globalThis и process

Стандарт ECMAScript определяет globalThis — ссылку на глобальный объект в любой среде. В Node это же самое делает global (исторический алиас), в браузере — window, в веб-воркере — self.

globalThis === global; // true в Node

process — не часть языка, а объект Node, описывающий сам процесс:

process.version;      // версия Node
process.env.NODE_ENV; // переменные окружения
process.argv;         // аргументы командной строки
process.platform;     // 'linux' | 'darwin' | 'win32'
process.pid;          // идентификатор процесса
process.exitCode = 1; // код возврата без немедленного выхода

Две вещи, которых в Node нет: document и window. DOM — часть браузера, а не JavaScript. Поэтому код, который обращается к document.querySelector, в Node упадёт с ReferenceError, даже если синтаксис языка полностью поддерживается.

При этом Node постепенно заимствует веб-API: fetch, URL, URLSearchParams, AbortController, EventTarget, TextEncoder, structuredClone доступны глобально. Граница между «браузерным» и «серверным» API размывается, но DOM остаётся браузерным.


Отличия от браузерного рантайма

АспектБраузерNode.js
ДвижокV8 / SpiderMonkey / JavaScriptCoreV8
Глобальный объектwindow, selfglobal, globalThis
DOMЕстьНет
Доступ к файламТолько через выбор пользователя, File APIПолный, node:fs
СетьОграничена CORS и разрешениямиЛюбые соединения, node:net
МодулиESM в сборкеCommonJS и ESM, node:*
МногопоточностьWeb Workersworker_threads, cluster
Время жизниВкладка, закрывается пользователемПроцесс, управляете вы
ПесочницаЕстьНет, это обычный процесс ОС
Точка входа<script> или бандлnode file.js, main в package.json

Отсюда практическое следствие: изоморфный код (общий для клиента и сервера) приходится писать осторожно — проверять наличие window или разделять модули по окружению.


Когда Node.js уместен

Сильные стороны вытекают прямо из архитектуры: дёшево ждать, дорого считать.

  • API и BFF — много параллельных запросов, каждый ждёт базу или внешний сервис.
  • Realtime — WebSocket, SSE, чаты, уведомления: тысячи долгоживущих соединений на один процесс.
  • Стриминг — проксирование, загрузка и выдача больших файлов без загрузки в память.
  • SSR и сборка — Next.js, Vite, ESLint: серверный рендеринг и инструменты фронтенда на том же языке.
  • CLI и автоматизация — скрипты, работа с файлами и процессами.
  • Единый язык на клиенте и сервере — общие типы, валидация и утилиты.

Общий знаменатель: нагрузка I/O-bound, где узкое место — ожидание, а не процессор.


Когда Node.js не подходит

  • Тяжёлые вычисления в запросе — обработка изображений, кодирование видео, ML-инференс, сложная криптография на каждый запрос. Один такой обработчик блокирует всех.
  • Жёсткий realtime — системы, где задержка измеряется микросекундами и важна предсказуемость: GC-паузы и однопоточная модель мешают.
  • Большие объёмы вычислений и памяти — аналитика, численные расчёты, обработка датасетов в гигабайтах: ограничение кучи и один поток становятся проблемой.
  • Задачи, где нужен зрелый набор библиотек — часть научных и системных областей лучше покрыта Python, Java, Go или C++.

Важно: «не подходит» не всегда окончательно. CPU-bound часть можно вынести в worker_threads, отдельный сервис на другом стеке или в очередь задач — тогда Node остаётся слоем API. Но если вычисления составляют основную нагрузку, проще взять подходящий инструмент сразу.


Эксперименты, которые объясняют рантайм

Теория запоминается хуже, чем наблюдение. Три коротких опыта, которые стоит выполнить локально.

1. Блокировка event loop

let last = Date.now();

setInterval(() => {
  const now = Date.now();
  console.log(`лаг: ${now - last - 100} мс`);
  last = now;
}, 100);

// блокируем главный поток на 2 секунды
const end = Date.now() + 2000;
while (Date.now() < end) {}

Пока крутится while, тиков нет. После выхода из цикла появится один тик с лагом около 1900 мс — это и есть остановка event loop.

2. Один поток на всех

import { createServer } from 'node:http';

createServer(async (req, res) => {
  if (req.url === '/block') {
    const end = Date.now() + 2000;
    while (Date.now() < end) {}
  }
  res.end('ok');
}).listen(3000);

Запустите два запроса: /block и сразу /. Второй ответит только после того, как первый освободит поток. Асинхронность не спасла, потому что блокировка синхронная.

3. Пул потоков

Код с pbkdf2 из раздела про пул. Сравните время выполнения при UV_THREADPOOL_SIZE=1, 2, 4 и 8 — увидите ступеньки, а не линейное ускорение: потоков фиксированное число, лишние задачи ждут.

Эти три опыта закрывают большинство вопросов на собеседовании об устройстве Node: где ждёт, где считает, где блокирует.


Ключевые тезисы для интервью

  • Node.js — рантайм, а не язык: V8 исполняет JavaScript, libuv даёт event loop и асинхронный ввод-вывод, модули node:* — доступ к системе.
  • JavaScript в приложении выполняется в одном потоке; «single-threaded» описывает исполнение кода, а не процесс, где есть пул libuv и служебные потоки V8.
  • Пул libuv (4 потока по умолчанию) обслуживает файлы, dns.lookup, криптографию и zlib; сокеты идут через ОС и пул не занимают.
  • Асинхронность — это не параллелизм: пока главный поток считает, event loop стоит, и сервис не отвечает даже на healthcheck.
  • globalThis — стандартный глобальный объект, global — алиас в Node; window и document отсутствуют, process и node:* есть.
  • Node силён в I/O-bound нагрузке и слаб в CPU-bound; вычисления выносят в worker_threads, очередь или отдельный сервис.

Заключение

Node.js даёт JavaScript доступ к системе через два слоя: V8 исполняет код в одном потоке, libuv обеспечивает event loop, неблокирующий ввод-вывод и пул фоновых потоков. Из этой архитектуры напрямую следуют и сильные стороны — дешёвое ожидание и десятки тысяч соединений, — и слабые: любая синхронная работа останавливает весь сервис. Понимание границы V8/libuv превращает вопросы «почему зависло» и «почему быстро» из магии в инженерные задачи, а выбор Node.js — из моды в осознанное решение под I/O-bound нагрузку.

Полезные ссылки