Event loop без магии: как JavaScript реально выполняет асинхронный код

•
Опубликовано
•
13 мин чтения

Текст написан с позиции июня 2018 года: так, как тема выглядела тогда, без технологий и событий, появившихся позже.

Асинхронность в JavaScript давно перестала быть экзотикой. Таймеры, AJAX-запросы, обработчики событий, Promise, а в последние годы и async/await стали повседневной частью фронтенд-разработки и серверного JavaScript. Но при всей популярности темы event loop до сих пор окружен мифами. Многие разработчики могут написать рабочий код с setTimeout и Promise, но не всегда до конца понимают, в каком порядке он будет реально выполняться.

Асинхронность выглядит как параллельность, но ею не является

Если вы пишете на JavaScript, вы постоянно сталкиваетесь с асинхронным поведением. Пользователь кликает по кнопке, приходит ответ от сервера, срабатывает таймер, обновляется интерфейс, отрабатывает цепочка Promise. Все это выглядит как «параллельная работа», хотя сам JavaScript в привычной среде исполнения остается однопоточным на уровне выполнения основного кода. Именно поэтому понимание event loop критично для любого, кто хочет писать предсказуемые интерфейсы, избегать гонок состояний, не блокировать браузер и уверенно проходить технические собеседования.

Проблема в том, что многие объяснения либо слишком упрощают модель, либо, наоборот, перегружают ее абстракциями. Кто-то говорит: «JavaScript однопоточный, но браузер делает магию». Кто-то повторяет: «Все колбэки уходят в очередь». Кто-то запоминает правило «Promise раньше setTimeout», но не понимает, почему именно так происходит. В результате знания получаются фрагментарными. А значит, в сложных сценариях возникают ошибки.

Самая вредная реакция на тему event loop — услышать слово «асинхронность» и решить, что речь про параллелизм и магию браузера. На самом деле всё проще и честнее. Если убрать упрощения, картина становится ясной: JavaScript-код выполняется в стеке вызовов, внешняя среда предоставляет механизмы для асинхронных операций, а event loop координирует момент, когда отложенные задачи могут вернуться обратно в выполнение. То есть никакой мистики здесь нет — это не параллельное выполнение, а конкретный порядок передачи управления.

Всё начинается со стека вызовов, а не с очередей

Чтобы понять event loop, сначала нужно понять базовую вещь: JavaScript не запускает сразу все подряд. Он выполняет код последовательно, вызов за вызовом, через call stack — стек вызовов. Когда интерпретатор встречает функцию, он кладет ее в стек. Когда функция завершилась, она убирается из стека. Пока стек занят, никакой callback не может просто «вклиниться» в середину уже идущего выполнения.

Посмотрим на максимально простой пример:

function first() {
    console.log('first');
}

function second() {
    console.log('second');
}

first();
second();

Здесь все предсказуемо: сначала в стек попадает глобальный контекст выполнения, затем вызов first(), затем функция завершается, потом вызывается second(). Порядок будет именно таким, потому что стек обрабатывает вызовы синхронно и последовательно.

Теперь добавим таймер:

console.log('start');

setTimeout(function() {
    console.log('timeout');
}, 0);

console.log('end');

Новички часто ожидают, что setTimeout(..., 0) выполнится «сразу». Но в реальности результат будет таким:

start
end
timeout

Почему? Потому что setTimeout не помещает callback напрямую в стек вызовов. Он лишь регистрирует задачу во внешней среде исполнения. Пока основной код не завершится и стек не опустеет, callback не может быть выполнен.

Таймеры и сеть дает не язык, а среда исполнения

Когда говорят «JavaScript выполняет асинхронный код», это формулировка не совсем точная. Сам язык JavaScript не содержит встроенного таймера, сетевого стека или DOM-событий. Эти возможности предоставляет среда исполнения. В браузере это Web APIs: setTimeout, события DOM, XMLHttpRequest, а также другие браузерные механизмы. В Node.js есть свои API, основанные на другой инфраструктуре.

Это различие важно. Event loop не является какой-то отдельной «функцией JavaScript». Это часть механизма выполнения, который связывает JavaScript-движок со средой исполнения. Поэтому, когда мы говорим про асинхронность, нужно мысленно разделять систему на части:

  • JavaScript-движок выполняет синхронный код и поддерживает стек вызовов.
  • Среда исполнения управляет таймерами, событиями, запросами и другими внешними операциями.
  • Очереди задач хранят callback-и, готовые к выполнению.
  • Event loop следит, когда можно передать задачу обратно в стек вызовов.

Это и есть рабочая модель, на которой строится поведение асинхронного кода.

Задержка в setTimeout — это минимум, а не обещание

Разберем путь выполнения таймера пошагово. Когда интерпретатор видит setTimeout(fn, 1000), происходит следующее:

  1. В стек вызовов попадает функция setTimeout.
  2. Среде исполнения передается callback fn и задержка в 1000 миллисекунд.
  3. setTimeout завершается и убирается из стека.
  4. Через указанное время callback становится готов к выполнению.
  5. Этот callback помещается в очередь задач.
  6. Event loop проверяет стек вызовов. Если он пуст, задача из очереди переносится в стек и выполняется.

Ключевая идея: задержка в setTimeout — это минимальное время ожидания, а не гарантия точного запуска. Если стек занят дольше, callback выполнится позже. Именно поэтому тяжелый синхронный код может «ломать» ожидания по времени.

Пример:

setTimeout(function() { console.log('timer'); }, 0);

for (var i = 0; i < 1000000000; i++) {}

console.log('done');

Несмотря на нулевую задержку, сначала завершится цикл, потом выведется done, и только потом сработает таймер. Причина проста: стек был занят, а event loop не может вставить callback внутрь уже выполняющегося синхронного кода.

Не все callback-и стоят в одной очереди

На этом этапе у многих складывается ощущение, что все асинхронные операции просто складываются в одну общую очередь. Но это не упрощение, а ошибка модели: в современных JavaScript-приложениях такого представления уже недостаточно. Важно понимать, что существуют разные типы задач, и порядок их обработки различается. В первую очередь нас интересуют две категории:

  • Macro task — крупные задачи, такие как setTimeout, setInterval, события интерфейса, сетевые события.
  • Micro task — более приоритетные задачи, в первую очередь обработчики Promise.then, catch, finally, а также некоторые другие механизмы среды.

Именно различие между ними объясняет, почему Promise почти всегда выполняются раньше таймеров, даже если таймер поставлен с нулевой задержкой.

Почему Promise выполняется раньше setTimeout

Рассмотрим классический пример:

console.log('script start');

setTimeout(function() {
    console.log('setTimeout');
}, 0);

Promise.resolve().then(function() {
    console.log('promise');
});

console.log('script end');

Результат будет таким:

script start
script end
promise
setTimeout

На первый взгляд это может удивлять. Ведь и таймер, и Promise как будто асинхронны. Но работают они через разные очереди. После завершения текущего синхронного блока event loop сначала обрабатывает все доступные micro task, и только потом переходит к следующей macro task.

Последовательность такова:

  1. Выполняется синхронная часть скрипта.
  2. setTimeout регистрирует macro task на будущее.
  3. Promise.resolve().then(...) создает micro task.
  4. После окончания основного кода стек освобождается.
  5. Event loop сначала очищает очередь micro task.
  6. Лишь затем берется следующая macro task, то есть callback таймера.

Это одно из самых важных правил event loop в современном JavaScript. Если его не понимать, можно легко ошибиться в порядке обновления данных, рендеринга или вызова колбэков.

Очередь micro task маленькая, но вычищается до конца

Очередь micro task особенно важна, потому что она полностью вычищается перед переходом к следующей macro task. Иначе говоря, если во время обработки одной micro task вы создаете следующую, она тоже будет выполнена до того, как event loop продолжит обычный цикл.

Посмотрим на пример:

Promise.resolve()
    .then(function() {
        console.log('microtask 1');
    })
    .then(function() {
        console.log('microtask 2');
    });

setTimeout(function() {
    console.log('macrotask');
}, 0);

Сначала отработают оба обработчика Promise, и только потом сработает таймер. Для разработчика это означает, что цепочки Promise могут заметно влиять на последовательность вычислений. Они не «почти как setTimeout», а ведут себя по другим правилам.

Это имеет не только теоретическое, но и практическое значение. Например, библиотека может использовать Promise для откладывания обновления состояния на «самый ближайший» возможный момент. Такой код выполнится раньше обычных таймеров и может изменить порядок побочных эффектов в приложении.

Весь цикл event loop укладывается в пять шагов

Если собрать все вместе, то упрощенно цикл event loop можно описать так:

  1. Выполнить текущий синхронный код до конца.
  2. Если стек пуст, взять задачи из очереди micro task и выполнить их все.
  3. Когда очередь micro task опустеет, взять одну macro task и выполнить ее.
  4. После выполнения этой macro task снова обработать все накопившиеся micro task.
  5. Повторять цикл.

Эта схема объясняет большую часть реального поведения JavaScript-кода в браузере. Она же позволяет понимать, почему чрезмерное количество micro task может задерживать другие события. Если постоянно генерировать новые micro task, переход к следующей macro task может откладываться.

Смешанный пример читается по модели, а не по интуиции

Теперь посмотрим на пример, где вместе используются синхронный код, Promise и таймер:

console.log('A');

setTimeout(function() {
    console.log('B');
}, 0);

Promise.resolve()
    .then(function() {
        console.log('C');
    })
    .then(function() {
        console.log('D');
    });

console.log('E');

Какой будет порядок? Правильный ответ:

A
E
C
D
B

Разбор:

Сначала выполняется синхронная часть. Поэтому выводятся A и E. Затем стек очищается, и event loop переходит к очереди micro task. Туда уже попал первый then, который выводит C. После его выполнения в micro task ставится следующий then, который выводит D. Только когда очередь micro task полностью пуста, event loop берет macro task от setTimeout, и мы видим B.

Именно так нужно рассуждать при чтении асинхронного JavaScript-кода: не по интуиции, а по модели стека и очередей.

Клик не врывается в уже выполняющийся код

Когда пользователь кликает по кнопке, это тоже не означает, что обработчик прямо мгновенно «врывается» в выполнение. Событие приходит из среды исполнения. Когда обработчик готов, он ставится в очередь задач. Но выполнится он лишь тогда, когда стек будет свободен.

Из этого вытекает важный практический вывод: если вы запускаете долгий синхронный код в основном потоке браузера, интерфейс перестает реагировать. Не потому что события не происходят, а потому что их обработчики не могут попасть в стек вызовов, пока текущая работа не завершится.

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

Браузер рисует между задачами, а не посреди них

Еще одна причина понимать event loop — взаимодействие JavaScript и отрисовки. Браузер не перерисовывает интерфейс в произвольный момент во время выполнения любого куска кода. Если основной поток занят длинной синхронной задачей, визуальные изменения могут не появляться на экране, даже если вы уже изменили DOM.

Именно поэтому иногда возникает ситуация, когда вы добавили элемент в DOM, поменяли CSS-класс, но пользователь не видит промежуточное состояние: JavaScript отработал слишком длинным блоком, и браузер не получил возможности выполнить отрисовку между шагами.

Для практики это означает простую вещь: если задача тяжелая, ее стоит дробить. Даже обычный setTimeout с небольшой задержкой может дать браузеру шанс обработать другие задачи и не «заморозить» страницу. Это не элегантное решение, а скорее дешёвый компромисс, но оно по-прежнему остается распространенной техникой разгрузки основного потока.

async/await меняет синтаксис, а не модель

К середине 2018 года async/await уже стал привычным инструментом для многих проектов. Из-за более «синхронного» внешнего вида иногда кажется, будто он меняет саму модель event loop. Но это не новая модель, а синтаксис поверх старой. async/await не отменяет Promise и не создает новую систему очередей. Он лишь делает асинхронный код удобнее для чтения.

Функция с async по-прежнему возвращает Promise, а await по сути приостанавливает выполнение внутри этой функции до тех пор, пока Promise не завершится. Продолжение работы также включается через механизм micro task.

async function run() {
    console.log('1');
    await Promise.resolve();
    console.log('2');
}

console.log('3');
run();
console.log('4');

Результат:

3
1
4
2

Почему так происходит? Потому что до await функция выполняется синхронно. После встречи с await продолжение откладывается как асинхронный шаг, связанный с Promise. Поэтому 2 выводится позже, когда текущий синхронный код уже завершен.

Для понимания event loop это важный момент: async/await делает код чище, но не делает его магическим.

Четыре заблуждения, которые сбивают рассуждение об асинхронности

Заблуждение 1: JavaScript умеет делать несколько вещей одновременно

Корректнее сказать так: JavaScript-код на основном потоке выполняется последовательно, а внешняя среда может параллельно ждать события, таймеры и сетевые операции. Когда результат готов, callback возвращается в очередь. Это не то же самое, что параллельное выполнение самого JavaScript-кода в одном и том же стеке.

Заблуждение 2: setTimeout(fn, 0) значит немедленно

Нет. Это значит «не раньше, чем через минимальную задержку и когда стек освободится». На практике выполнение почти всегда произойдет позже, чем думают новички.

Заблуждение 3: Promise — это просто современный setTimeout

Тоже нет. Promise используют очередь micro task, а не обычную очередь macro task. Из-за этого они имеют другой приоритет и другой порядок исполнения.

Заблуждение 4: если код асинхронный, значит он не блокирует интерфейс

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

Что из этой модели следует для ежедневной работы

Понимание event loop полезно не только для теории. Вот несколько практических выводов, которые помогают писать более надежный JavaScript-код:

  • Не рассчитывайте на точный порядок по наитию — мысленно раскладывайте код на синхронную часть, micro task и macro task.
  • Не используйте setTimeout(..., 0) как «гарантированно мгновенный» вызов.
  • Помните, что длинные цепочки Promise тоже влияют на порядок выполнения и могут задерживать другие задачи.
  • Избегайте тяжелых синхронных вычислений в основном потоке, особенно в браузере.
  • При разборе багов, связанных с состоянием интерфейса, всегда проверяйте, не связано ли поведение с очередностью задач.

Очень часто проблема, которую называют «странным багом JavaScript», на деле оказывается просто непонятым порядком исполнения. Один callback пришел раньше другого, Promise завершился до таймера, изменение DOM произошло до перерисовки, а тяжелый цикл заблокировал обработчик клика. Все это — обычные последствия одной и той же модели.

Понимание event loop меняет то, как читается код

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

Event loop — это не просто тема для собеседований. Это фундаментальная часть модели JavaScript. Разобравшись с ним, вы начинаете иначе читать код. Вы уже не видите асинхронность как набор «хаков» и «магических задержек». Вместо этого вы понимаете, что происходит в каждый конкретный момент: что сейчас в стеке, что ожидает в очереди, какая задача имеет приоритет и когда реально выполнится ваш callback.

Именно это отличает поверхностное знание синтаксиса от инженерного понимания платформы. Можно долго писать работающий код на интуиции, но по-настоящему уверенно управлять поведением приложения получается только тогда, когда вы понимаете механику исполнения.

Заключение

Event loop в JavaScript не требует веры в магию. Его можно объяснить через несколько конкретных сущностей: стек вызовов, среду исполнения, очередь macro task и очередь micro task. Синхронный код всегда выполняется первым. Таймеры и события ждут своей очереди. Promise имеют более высокий приоритет и обрабатываются раньше обычных задач. Пока стек занят, никакой callback не начнет выполняться.

Если удерживать в голове эту модель, многие «неожиданные» результаты становятся абсолютно логичными. Почему Promise.then раньше setTimeout? Почему таймер с нулевой задержкой не мгновенный? Почему интерфейс может зависнуть из-за обычного цикла? Почему async/await не отменяет правила event loop? На все эти вопросы есть четкий ответ, если смотреть на JavaScript как на систему очередей и стека, а не как на набор исключений.

Асинхронный JavaScript уже давно стал стандартом индустрии, и чем активнее используются Promise,async/await и сложные интерфейсы, тем важнее понимать основу. Event loop — именно такая основа. Когда эта модель в голове, поведение асинхронного кода перестает быть неожиданным и становится предсказуемым.

Главный практический вывод: event loop — это не источник магии, которой надо бояться, а детерминированная модель порядка исполнения, и как только вы держите её в голове, асинхронный код перестаёт быть лотереей и становится тем, что вы контролируете осознанно.

Автор

Senior Principal JavaScript Developer, Tech Lead. Пишет о React, TypeScript, React Native, архитектуре фронтенда и бэкенда и о том, как AI меняет работу разработчика.

Обновлено

Читайте также