菲利普·罗伯茨拆解事件循环 揭示JavaScript借Web API实现并发机制

What the heck is the event loop anyway? | Philip Roberts | JSConf EU — JSConf

JSConf

JavaScript引擎自身虽为严格单线程,但浏览器通过后台Web API线程接管耗时任务,并在调用栈清空后由事件循环将回调压回主线程执行,从而避免界面重绘彻底冻结。

AI-assisted summary of What the heck is the event loop anyway? | Philip Roberts | JSConf EU — original source. Check the original for full context.

Source published:

Key ideas

  • JavaScript 引擎(如 V8)本身仅包含调用栈与内存堆,并不包含 `setTimeout`、DOM API 或事件循环,这些机制均由浏览器宿主环境的 Web APIs 与外部调度系统提供。 (1:26)
  • 事件循环的核心职责十分单一:持续监控调用栈,仅在调用栈完全清空时,才会将任务队列中的首个回调函数压入栈中执行。 (12:19)
  • `setTimeout(fn, delay)` 设定的时间并非绝对执行时刻,而仅代表回调进入任务队列的最小等待延迟,`setTimeout(fn, 0)` 的本质是推迟执行直到当前主栈完全清空。 (14:55)
  • 浏览器渲染机制约每 16.6 毫秒(60 FPS)请求一次重绘,但无法强行抢占正在运行的 JavaScript 栈帧;任何长耗时同步任务都会直接导致页面掉帧与交互冻结。 (22:15)

Detailed notes

## Background 该视频由 JSConf 官方频道于 2014 年 10 月 9 日发布在 YouTube 上,记录了 Philip Roberts 在 JSConf EU 大会上的演讲。页面简介提到,JavaScript 开发者经常挂在嘴边的“事件循环”、“非阻塞”与“单线程”等术语往往让人似懂非懂,本场演讲旨在通过直观的可视化演示与趣味黑客技巧,帮助大家真正建立对 JavaScript 运行机制的直观理解。

## TL;DR 演讲深入剖析了 JavaScript 作为单线程语言如何在浏览器中实现非阻塞并发的核心奥秘。Philip Roberts 澄清了 V8 引擎仅包含调用栈与内存堆的事实,指出 DOM、AJAX 与 setTimeout 等异步能力实则来自宿主环境的 Web APIs。通过自行开发的可视化工具 Loupe,他生动演示了任务队列与事件循环的协作流程:只有当主调用栈完全清空时,事件循环才会将排队的回调推入执行。最后,演讲探讨了阻塞调用栈对 60 FPS 渲染管线的破坏性影响,并给出了拆分异步长任务与利用防抖(Debounce)优化高频事件的实用建议。

## Atmosphere & style 整场演讲幽默自嘲、充满活力且启发性极强。Philip Roberts 巧妙地以自身作为资深工程师却对底层概念一知半解的“坦白”切入,瞬间拉近了与台下开发者的心理距离。随着他演示自制可视化工具 Loupe 的动态交互,复杂抽象的底层调度变得极度具象且充满趣味,现场伴随着会心的笑声与豁然开朗的赞叹,给观众带来一种穿透技术黑盒、恍然大悟的爽快感。

## Bulletin - [01:26](https://www.youtube.com/watch?v=8aGhZQkoFbQ&t=86s) JavaScript 引擎(如 V8)本身仅包含调用栈与内存堆,并不包含 `setTimeout`、DOM API 或事件循环,这些机制均由浏览器宿主环境的 Web APIs 与外部调度系统提供。 - [12:19](https://www.youtube.com/watch?v=8aGhZQkoFbQ&t=739s) 事件循环的核心职责十分单一:持续监控调用栈,仅在调用栈完全清空时,才会将任务队列中的首个回调函数压入栈中执行。 - [14:55](https://www.youtube.com/watch?v=8aGhZQkoFbQ&t=895s) `setTimeout(fn, delay)` 设定的时间并非绝对执行时刻,而仅代表回调进入任务队列的最小等待延迟,`setTimeout(fn, 0)` 的本质是推迟执行直到当前主栈完全清空。 - [22:15](https://www.youtube.com/watch?v=8aGhZQkoFbQ&t=1335s) 浏览器渲染机制约每 16.6 毫秒(60 FPS)请求一次重绘,但无法强行抢占正在运行的 JavaScript 栈帧;任何长耗时同步任务都会直接导致页面掉帧与交互冻结。

## Key takeaways - [04:16](https://www.youtube.com/watch?v=8aGhZQkoFbQ&t=256s) JavaScript 运行时是单线程的,仅拥有一个调用栈,同一时间只能执行一段代码,进入函数入栈、返回出栈,无限递归会导致调用栈溢出(爆栈)。 - [01:26](https://www.youtube.com/watch?v=8aGhZQkoFbQ&t=86s) V8 引擎源码中不存在 `setTimeout`、AJAX 或 DOM 操作代码,异步并发能力完全来自浏览器提供的外部 Web APIs(在 Node.js 中对应 C++ APIs)。 - [07:18](https://www.youtube.com/watch?v=8aGhZQkoFbQ&t=438s) 长时间占用调用栈的慢速同步代码(如复杂的 `while` 循环)会彻底阻塞浏览器,导致页面失去响应、交互搁置且无法重新渲染。 - [12:19](https://www.youtube.com/watch?v=8aGhZQkoFbQ&t=739s) Web APIs 运行在后台独立线程中处理计时或网络请求,并在完成后将对应的回调推入任务队列,绝对无法直接插手或篡改调用栈。 - [14:55](https://www.youtube.com/watch?v=8aGhZQkoFbQ&t=895s) 事件循环在调用栈变空之前绝不会从任务队列中调度任何任务,因此所有同步代码永远优先于排队的回调函数执行完。 - [14:55](https://www.youtube.com/watch?v=8aGhZQkoFbQ&t=895s) `setTimeout(..., 0)` 并不能实现即时运行,而是作为一种代码延迟执行技巧,确保某些逻辑在调用栈彻底出栈后再执行。 - [20:16](https://www.youtube.com/watch?v=8aGhZQkoFbQ&t=1216s) 回调函数存在同步与异步之分:`Array.prototype.forEach` 是完全同步执行并占满调用栈的,而通过定时器拆分的异步回调才会进入任务队列分批调度。 - [22:15](https://www.youtube.com/watch?v=8aGhZQkoFbQ&t=1335s) 浏览器的界面渲染拥有比普通任务队列更高的优先级,但它同样必须排队等待调用栈清空后才能执行界面绘制。 - [22:15](https://www.youtube.com/watch?v=8aGhZQkoFbQ&t=1335s) 高频触发的 DOM 事件(如滚动 `scroll`)如果未做防抖或节流处理,会导致大量回调瞬间淹没任务队列,形成严重的渲染排队卡顿。 - [25:58](https://www.youtube.com/watch?v=8aGhZQkoFbQ&t=1558s) 可视化演示工具 Loupe 借助 Esprima 语法解析器在代码关键节点注入耗时 `while` 循环以实现慢动作,并放入 Web Worker 独立运行避免冻结主界面。

## Detailed walkthrough ### [00:01](https://www.youtube.com/watch?v=8aGhZQkoFbQ&t=1s) 演讲开场与一个困惑已久的疑问

主持人向大家介绍菲利普·罗伯茨(Phillip Roberts),他任职于专门从事实时开发的小型咨询公司 &yet(AndYet),来自苏格兰爱丁堡。菲利普登台后,看到分会场座无虚席感到非常兴奋,并打趣地让台下所有人跟他一起伸个懒腰,好让自己看起来不那么奇怪。

菲利普随后直奔主题,谈起这次演讲的核心命题:“事件循环(Event Loop)到底是个什么鬼东西?”他坦言,大约在 18 个月前,自己虽然已经是一名拿薪水的全职专业 JavaScript 开发者,但内心深处却产生了一个疑问:JavaScript 究竟是如何运转的?在当时,他对底层的很多概念其实一知半解。他常听人提起 V8、Chrome Runtime 之类的词汇,却根本不知道它们具体负责什么;他也知道 JavaScript 是“单线程”的,也一直在写回调函数,但他搞不懂回调函数到底是怎么运行的。这促使他开启了一段阅读、研究并在浏览器中动手实验的探索之旅。

[01:26](https://www.youtube.com/watch?v=8aGhZQkoFbQ&t=86s) 寻找答案的死胡同与完整的浏览器架构

菲利普幽默地模拟了自己当时与 JavaScript 的对话。当他问 JavaScript“你到底是什么”时,得到的教科书回答是:“我是单线程单并发语言,我有一个调用栈(Call Stack)、一个事件循环(Event Loop)、一个回调队列(Callback Queue)以及一些其他 API”。由于菲利普并没有计算机科学学位,这些术语听起来既抽象又令人困惑。于是他转向 Chrome 的 JavaScript 引擎 V8 寻求答案,以为能从中找到所有这些组件,结果翻看 V8 源码时才发现,V8 基本上只有调用栈和用于内存分配的堆(Memory Heap)。关于事件循环、回调队列或者其他 API,V8 里根本不存在。

更让他震惊的是,当他在 V8 源码中查找日常开发中最常见的异步要素(如 `setTimeout`、DOM 操作或 HTTP 请求)时,竟完全找不到这些东西的踪影。正如菲利普所总结的:“It's first thing you use when you start thinking about async stuff and it's not in the V8 source.” 经过长达 18 个月的摸索,他终于拼凑出了全局图景:V8 等运行时仅仅是整个生态的一部分,浏览器还提供了额外的 Web API(包括 DOM、AJAX、计时器等),而在它们之间穿针引线的,正是看似神秘的事件循环和任务/回调队列。

```mermaid flowchart TD accTitle: 浏览器环境完整架构图 accDescr: 展示 JavaScript 运行时、Web API、回调队列与事件循环之间的协作关系

subgraph Runtime["JavaScript 运行时 (例如 V8)"] Heap["内存堆 (Heap)<br/>内存分配"] Stack["调用栈 (Call Stack)<br/>执行帧 / 单线程"] end

subgraph Browser["浏览器宿主环境"] WebAPIs["Web APIs<br/>DOM, AJAX, setTimeout..."] Queue["回调队列 (Callback Queue)<br/>onClick, onLoad, onDone..."] EventLoop["事件循环 (Event Loop)"] end

Stack -.->|"调用 Web API"| WebAPIs WebAPIs -.->|"任务完成推入"| Queue Queue -.->|"被调度送回"| EventLoop EventLoop -.->|"栈清空时压入"| Stack ```

[04:16](https://www.youtube.com/watch?v=8aGhZQkoFbQ&t=256s) 单线程与调用栈(Call Stack)的运作机制

菲利普从最基础的机制讲起,深入剖析了 JavaScript 的单线程本质。所谓单线程运行时,意味着它只有一个调用栈,同一时间只能做一件事。为了具象化这个概念,他用一段简单的代码进行演示:一个将两个数字相乘的 `multiply` 函数、一个调用乘法计算平方的 `square` 函数,以及一个调用 `square` 并打印结果的 `printSquare` 函数。

调用栈本质上是一种记录程序当前运行位置的数据结构:进入一个函数就将其压入栈顶(push),从函数返回时就从栈顶弹出(pop)。当文件开始执行时,首先入栈的是代表整个脚本的 `main` 函数;随后执行到 `printSquare(4)`,将其推入栈中;在 `printSquare` 内部调用了 `square(4)`,再次入栈;`square` 又调用了 `multiply(4, 4)` 进栈;`multiply` 计算完成后执行 `return`,该函数出栈;接着 `square` 返回出栈;随后调用栈执行 `console.log` 输出结果并完成;最后 `printSquare` 运行完毕并随同主文件退出栈,整个调用栈归零。

菲利普指出,哪怕开发者以前没有刻意关注过调用栈,在平时调试浏览器代码时也肯定接触过。例如,当一个嵌套调用的函数抛出未捕获的错误时,Chrome 控制台打印出的调用栈轨迹(Stack Trace)清晰展示了崩溃时栈内的逐层状态:`Foo`、`Bar`、`Baz` 以及最外层的匿名主函数 `main`。类似地,如果编写一个无限递归调用自身的 `foo` 函数,调用栈就会被不断塞满,直到 Chrome 抛出“RangeError: Maximum call stack size exceeded”(即所谓的爆栈 Blow the stack),自动终止程序以防止崩溃。

- **调用栈的作用**:记录当前代码执行到了哪一步。 - **基本操作行为**:进函数 push 入栈,遇 return 或执行完毕 pop 出栈。 - **调用栈溢出(Blowing the stack)**:递归无终止条件导致超出栈容量,浏览器通常在达到约 16,000 次调用时主动报错中断。

[07:18](https://www.youtube.com/watch?v=8aGhZQkoFbQ&t=438s) 为什么代码会阻塞?同步带来的浏览器灾难

既然 JavaScript 只有一个线程和一个调用栈,那么当操作变慢时会发生什么?菲利普讨论了阻塞(Blocking)的概念。虽然技术上对什么是阻塞没有严格的唯一定义,但简而言之,任何慢速的代码都会造成阻塞。`console.log` 不慢,但执行一个从 1 数到 100 亿的 `while` 循环就会慢,网络请求、图像加载同样十分缓慢。当这些耗时很长的操作霸占在调用栈上时,就是所谓的阻塞行为。

为了直观展示这一点,菲利普假设如果 AJAX 网络请求是同步的(比如伪代码中的 `getSynchronous`),会发生什么局面:程序调用同步请求后必须干等(Wait),直到请求完成才能执行下一步;随后再发一个请求,继续干等。如果网络出现故障,请求永远无法完成,程序就彻底被挂起。

随后菲利普在屏幕上打开 Chrome 进行了现场演示。由于在浏览器中模拟同步请求比较繁琐,他用一个空转 5 秒钟的庞大 `while` 循环伪装成同步网络请求。当他点击“Run”按钮执行这段代码时,灾难发生了: 1. 页面完全失去响应,甚至 Run 按钮的点击重绘状态都无法完成渲染。 2. 开发者在界面上的任何点击操作均被搁置,浏览器陷入彻底的“假死”冻结状态。 3. 菲利普对此生动地描述道:“The browser is blocked, it's stuck, it can't do anything until those requests complete.” 4. 直到 5 秒的同步执行彻底结束,之前积压的用户交互操作才一口气爆发出来。

菲利普强调,这正是单线程在浏览器端面临的最大痛点:只要调用栈上有代码在执行,浏览器就无法重新渲染界面,也无法响应任何其他事件。如果想让用户获得丝滑流畅的 UI 交互,就绝对不能阻塞调用栈。

[10:22](https://www.youtube.com/watch?v=8aGhZQkoFbQ&t=622s) 异步回调与并发魔法的揭秘

为了解决调用栈阻塞的问题,JavaScript 给出的核心方案是异步回调(Asynchronous Callbacks)。无论在浏览器端还是 Node.js 环境中,绝大部分底层任务都被设计成异步的:调用某个函数,传入一个回调函数,稍后再去执行它。

菲利普给出了一个极其经典的测试样例: 1. `console.log('hi')` 2. `setTimeout(function cb() { console.log('there'); }, 5000)` 3. `console.log('JSConfEU')`

按照调用栈的直觉理解,先打印出 `hi`,然后遇到 `setTimeout`。我们知道传给它的回调不会立刻执行,而是要在 5 秒后触发,但它显然无法一直停留在调用栈上占位。神奇的是,`setTimeout` 瞬间就从调用栈上消失了,接着代码毫无停滞地执行并打印出 `JSConfEU`,调用栈被完全清空。而在整整 5 秒钟之后,回调函数仿佛被施了魔法一样凭空回到了调用栈中,打印出 `there`。

这种“消失又出现”的现象究竟是如何做到的?菲利普在此揭开了演讲的核心真相:“Right, so I've been kind of partially lying to you and telling you that JavaScript can only do one thing at one time.” 他解释道,虽然 JavaScript 运行时(如 V8)本身确实同一时刻只能做一件事,既不能在跑业务逻辑的同时发网络请求,也不能在执行代码的同时做定时等待,但浏览器本身绝不仅仅只有 JavaScript 运行时。浏览器提供的 Web API 具备真正的多线程并发能力,而事件循环正是协调这些组件协同工作的关键纽带。

[12:19](https://www.youtube.com/watch?v=8aGhZQkoFbQ&t=739s) 浏览器的 Web APIs、任务队列与事件循环的核心职责

浏览器并不仅包含 V8 这样的单一 JavaScript 运行时,它还额外提供了许多被称为 Web APIs 的底层能力。这些 Web APIs 本质上是浏览器在后台开启的线程,开发者只需在 JavaScript 中调用它们,并发处理(concurrency)便由此介入。Philip Roberts 指出,如果你是后端开发者,Node.js 的内部架构图与此基本相同,只不过浏览器端的 Web APIs 在 Node 端被替换成了 C++ APIs,多线程的复杂性全部被封装在了 C++ 背后。

当 JavaScript 执行 `setTimeout(callback, delay)` 时,该 API 并不存在于 V8 引擎内部,而是浏览器运行时提供的外部扩展。浏览器会为此接管倒计时任务。此时,调用栈中的 `setTimeout` 本身已经执行完毕并立即出栈(Pop),主线程得以继续向下执行后续代码(例如打印 `"JSConfEU"`)。当五秒倒计时结束后,Web API 并不能直接把回调函数扔回调用栈里,否则这些代码就会毫无预兆地随机插入到正在执行的主流程中。为了保证执行的可预测性,Web API 在完成任务后会将回调函数推入“任务队列”(Task Queue,亦称 Callback Queue)。

至此,演讲的主角——事件循环(Event Loop)登场。Philip Roberts 说明:“The event loops job is to look at the stack and look at the task queue. If the stack is empty it takes the first thing on the queue and pushes it on to the stack which effectively run it.”(事件循环的工作就是看着调用栈,同时看着任务队列;一旦调用栈变空,它就取出任务队列中的第一项并推入调用栈,从而让它执行)。只有当主栈完全清空后,事件循环才会将队列中的回调推回 V8 的执行栈中,回调里的 `console.log("there")` 才能最终完成打印。

```mermaid flowchart LR accTitle: JavaScript 运行时与事件循环架构 accDescr: 展示调用栈、Web APIs、任务队列以及事件循环之间协同工作的流程图。

subgraph Runtime["JavaScript 运行时 (V8)"] Stack["调用栈 (Call Stack)"] end

subgraph Browser["浏览器环境"] WebAPIs["Web APIs\n(Timer / DOM / AJAX)"] Queue["任务队列 (Task Queue)"] end

Stack -->|"调用异步 API"| WebAPIs WebAPIs -->|"计时/网络完成"| Queue Queue -.->|"栈清空时出队推入"| Loop(("事件循环\nEvent Loop")) Loop -.->|"推入执行"| Stack ```

- `setTimeout` 并非 V8 源码的一部分,而是由运行环境(浏览器或 Node.js)提供的外部 API。 - Web APIs 在后台独立线程处理计时或网络请求,倒计时结束后仅将回调注入任务队列,不能直接篡改调用栈。 - 事件循环的角色极其纯粹且单一:不断检测调用栈是否为空,若为空且队列中有排队任务,便将首个回调压入调用栈。

---

[14:55](https://www.youtube.com/watch?v=8aGhZQkoFbQ&t=895s) 解密 `setTimeout(fn, 0)` 与通用异步 API 机制

初学异步 JavaScript 时,开发者常常会遇到要求编写 `setTimeout(fn, 0)` 的古怪建议。很多人第一反应都是大惑不解:既然要等待 0 毫秒立即执行,为何还要特意包一层 `setTimeout`?Philip Roberts 坦言,自己第一次见到这种写法时也是一头雾水:“The reason is, generally, if you're trying to defer something until the stack is clear.”(其原因通常在于,你试图将某些操作推迟到调用栈完全清空之后再执行)。

即使延迟设定为 0 毫秒,浏览器的 Web API 也会立即将回调放入任务队列。然而,由于事件循环必须严格等待当前的调用栈全部清空,后续的同步代码(如打印 `"hi"`、`"JSConfEU"`)依然会优先在主栈中跑完。直到主线程代码全部出栈,事件循环才介入并将排队的回调推上调用栈。

所有异步 Web APIs 都遵循完全相同的模式。以常见的 AJAX 请求为例,发起请求时传入回调与目标 URL,具体执行网络传输的代码并不在 JavaScript 运行时里,而是在浏览器的 Web API 线程池中转动。在此期间,主调用栈无需等待网络返回,可以顺畅执行后续代码;甚至即使 XHR 请求失败或永远没有响应,主栈也不会挂起。一旦请求成功返回,回调即被推入队列,等待事件循环在空闲时拉取执行。

- `setTimeout(..., 0)` 并不能实现真正的“即刻运行”,而是实现代码执行的延迟(Defer),强制其排在当前调用栈全部出栈之后。 - 异步 AJAX 请求将繁重的 I/O 等待卸载到浏览器宿主环境,使单线程 JavaScript 能够持续响应。

---

[16:58](https://www.youtube.com/watch?v=8aGhZQkoFbQ&t=1018s) 演示工具 Loupe 的诞生与真实交互队列观察

为了直观展示复杂的执行流程,Philip Roberts 原本在 Keynote 幻灯片里手工制作了大约 500 个极其繁琐的动画步骤。但在苏格兰 JS 大会(Scotland JS)后,幻灯片坏了一半,重新在 Keynote 里排版调整极其痛苦。于是,他选择了一条幽默的“偷懒”捷径——索性自己动手写了一套名为 Loupe 的可视化工具,在运行时实时模拟 JavaScript 运行时、Web APIs、任务队列与事件循环的动态流转。

在 Loupe 中运行包含 DOM 点击监听(`addEventListener`)和 `setTimeout` 的代码,可以清晰看到调用栈如何迅速消费同步逻辑,并将事件监听注册到 Web APIs 区块。当用户在页面上点击按钮时,Web API 立即触发并将对应的点击回调推入任务队列。如果快速连续点击按钮 100 次,这些点击事件并不会立刻穿透到 JavaScript 引擎执行,而是全数堆积在任务队列中排队。主栈在处理完当前指令后,由事件循环逐个将点击回调拉入栈中处理。

这进一步揭示了计时器的真实语义。如果连续调用 4 次延迟为 1 秒的 `setTimeout` 并紧随一个同步的打印,当第四个定时器在 Web API 中到期并排入任务队列时,由于前面有正在等待或执行的回调,第四个回调实际被调用的时间必然远远超出设定的 1 秒。Philip Roberts 强调指出:“...it's not a guaranteed time to execution, it's a minimum time to execution, just like setTimeout zero doesn't run the code immediately it runs the code next‑ish, sometime, right?”(……它并不是保证执行的时间点,而是一个最小执行延迟;就像 `setTimeout` 设为 0 并不会马上执行代码,而是在接下来的某个时刻执行,对吧?)。

- Loupe 是作者为了规避 Keynote 繁复动画制作而开发的可视化调试与教学工具。 - 用户交互(如点击事件)在宿主层触发后,必须转化为队列中的任务,按先进先出顺序等待调度。 - `setTimeout(fn, delay)` 中的 `delay` 仅代表回调进入任务队列的最小等待时间,绝非精确的执行时刻保证。

---

[20:16](https://www.youtube.com/watch?v=8aGhZQkoFbQ&t=1216s) 同步回调与异步回调的辨析

在日常技术讨论中,“回调”(Callback)一词经常引发概念混淆。Philip Roberts 澄清,回调在语境中通常包含两种含义:广义上指代“任何被另一个函数调用的函数”;而在异步编程的严格语境下,则特指“未来会被推入回调队列的异步函数”。

以数组内置的 `forEach` 方法为例,虽然它接受一个函数参数并习惯被称为回调,但它完全是同步执行的,每一个迭代调用都直接堆叠在当前调用栈中,牢牢霸占主线程,直到整个数组遍历结束才让出。如果手动封装一个利用 `setTimeout(..., 0)` 实现的异步版 `asyncForEach`,行为则截然不同:它在循环中迅速将每一次处理包装为异步任务投递到 Web APIs 和任务队列,从而迅速清空当前的同步栈,使后续的同步输出能够立刻执行,之后再由事件循环逐个消化各元素的回调。

```javascript // 同步 forEach:回调直接在当前调用栈中执行,阻塞主线程 [1, 2, 3, 4].forEach(function(i) { console.log(i); });

// 异步 forEach:利用异步 API 将每次执行推迟到任务队列 function asyncForEach(array, cb) { array.forEach(function(item) { setTimeout(function() { cb(item); }, 0); }); } ```

- 同步回调(如原生 `Array.prototype.forEach`)同步占用调用栈,栈未执行完前外部代码完全停滞。 - 异步回调借助调度机制解耦,各迭代项作为独立任务排入任务队列,分批次被调用栈执行。

---

[22:15](https://www.youtube.com/watch?v=8aGhZQkoFbQ&t=1335s) 浏览器渲染管线、掉帧与“不要阻塞事件循环”

JavaScript 的单线程机制对浏览器的渲染管线(Render Pipeline)有着决定性的制约。理想状态下,为了呈现流畅的用户界面,浏览器期望以每秒 60 帧(60 FPS)的速率重绘屏幕,也就是大约每 16.6 毫秒就要执行一次重绘(Repaint/Render)。然而,只要当前 JavaScript 调用栈中有任何代码正在运行,浏览器就无法插入渲染流程。渲染流程在行为上类似于一个拥有更高优先级的特殊回调:它大约每 16 毫秒就会发起一次重绘请求,但前提是必须静候调用栈彻底清空。

Philip Roberts 现场展示了他在演示工具中加入的重绘模拟机制。当主线程运行耗时严重的同步循环处理时,渲染队列被彻底锁死。在重绘受阻的这段时间里,用户在屏幕上无法选中文本,点击按钮没有任何视觉反馈,页面呈现死锁状态。相反,如果将耗时计算拆解为异步批处理,虽然在推入定时器时会有极短暂的微小占用,但在每次处理元素之间,调用栈都会清空,从而让浏览器的渲染机制有机会穿插进来完成界面绘制。

谈及社区常说的性能箴言,Philip Roberts 总结道:“They're saying don't put shitty slow code on the stack because when you do that the browser can't do what it needs to do, create a nice fluid UI.”(他们是在说,不要把又烂又慢的代码往栈上扔,因为一旦你这么做了,浏览器就无法完成它该做的工作——打造一个丝滑流畅的用户界面)。不仅低效的同步运算会阻塞调用栈,不加节制的事件处理同样会拖垮系统。例如 DOM 中的滚动事件(`scroll`)在滑动时会高频触发(甚至达到每 16 毫秒触发一次)。如果在 `document.scroll` 的回调中绑定沉重复杂的动画或运算,虽然单次调用并没有长期占死栈空间,但海量的回调会像洪水一样瞬间淹没任务队列(Flooding the queue),造成灾难性的排队卡顿。

- 浏览器理想刷新频率为 60 FPS(每帧约 16.6ms),任何驻留在调用栈中的长任务都会直接推迟重绘并引发掉帧。 - 渲染调度虽然比普通任务队列中的异步回调拥有更高优先级,但依然无法强行抢占(Preempt)正在执行的 JavaScript 栈帧。 - 高频触发的事件(如滚动、手势等)如果未做防抖或节流,会导致任务队列泛滥积压,形成严重的界面滞后。

[25:35](https://www.youtube.com/watch?v=8aGhZQkoFbQ&t=1535s) 防抖优化与事件循环的实际应用

在处理诸如滚动(scroll)事件等会高频触发的回调函数时,很容易导致调用栈和任务队列被严重阻塞,进而引发界面卡顿。Philip Roberts 指出,面对这种情况可以通过防抖(debounce)技术来进行性能优化。这种方案的核心思想在于对事件进行排队和合并控制,避免每一次触发都立即执行耗时的复杂计算,而是“每隔几秒钟执行一次慢速任务,或者直到用户停止滚动一段时间后再执行”。通过这种控制执行节奏的方式,可以保证页面响应灵敏,不会因为大量回调堆积而直接卡死浏览器的渲染通道。

```mermaid flowchart TD accTitle: 事件防抖机制 accDescr: 展示高频触发事件如何通过防抖机制合并处理,以避免阻塞调用栈。

subgraph Trigger["高频触发阶段"] E1["滚动事件 1"] E2["滚动事件 2"] E3["滚动事件 N"] end

subgraph Control["防抖控制层"] D["Debounce 调度"] end

subgraph Exec["执行阶段"] W["执行耗时计算任务 / 渲染"] end

E1 --> D E2 --> D E3 --> D D -->|"用户停止滚动后 / 间隔触发"| W ```

[25:58](https://www.youtube.com/watch?v=8aGhZQkoFbQ&t=1558s) 可视化演示工具的实现幕后与结语

为了向观众清晰展示事件循环的内部运行机制,Philip Roberts 自制了一款专门的可视化工具(即著名的 Loupe)。在演讲接近尾声时,他笑着向大家揭秘了该工具在底层究竟是如何实现“慢动作”动画效果的。他坦言这套工具的实现细节非常丰富,直言:“There's a whole other talk in how the hell this works.”

这段代码之所以能够在页面上以极慢的节奏逐步呈现,是因为它在运行时被动态处理了:程序首先会通过 JavaScript 语法解析器 Esprima 对输入的代码进行解析和语法分析,随后在代码的关键节点之间硬编码插入一个耗时约半秒的大型 `while` 循环,从而人工为代码执行加上“慢动作放慢滤镜”。紧接着,代码会被派发到 Web Worker 中运行,并配合大量的前端交互与状态捕捉逻辑,实时还原调用栈、Web API、任务队列与事件循环之间的协同状态。Philip Roberts 表示自己对这个工具的实现机制感到非常兴奋,并热情邀请对技术细节感兴趣的参会者在演结束后与他线下交流。

- **解析与插桩**:利用 JavaScript AST 解析器 Esprima 解析用户编写的代码,并在代码执行路径中注入耗时约半秒的 `while` 循环来实现慢镜头执行效果。 - **后台隔离**:将经过处理的代码交由 Web Worker 独立执行,以此在不冻结主界面渲染的前提下实时监控运行状态并生成可视化视图。

## Notable quotes > [12:19](https://www.youtube.com/watch?v=8aGhZQkoFbQ&t=739s) The event loops job is to look at the stack and look at the task queue. If the stack is empty it takes the first thing on the queue and pushes it on to the stack which effectively run it. — Philip Roberts

> [22:15](https://www.youtube.com/watch?v=8aGhZQkoFbQ&t=1335s) They're saying don't put shitty slow code on the stack because when you do that the browser can't do what it needs to do, create a nice fluid UI. — Philip Roberts

## Mentioned Philip Roberts, JSConf EU, &yet, JavaScript, Chrome, V8, Node.js, Loupe, Keynote, Scotland JS, Esprima, Web Worker

## Video description JavaScript programmers like to use words like, “event-loop”, “non-blocking”, “callback”, “asynchronous”, “single-threaded” and “concurrency”.

We say things like “don’t block the event loop”, “make sure your code runs at 60 frames-per-second”, “well of course, it won’t work, that function is an asynchronous callback!”

If you’re anything like me, you nod and agree, as if it’s all obvious, even though you don’t actually know what the words mean; and yet, finding good explanations of how JavaScript actually works isn’t all that easy, so let’s learn!

With some handy visualisations, and fun hacks, let’s get an intuitive understanding of what happens when JavaScript runs.

Transcript: http://2014.jsconf.eu/speakers/philip-roberts-what-the-heck-is-the-event-loop-anyway.html

License: For reuse of this video under a more permissive license please get in touch with us. The speakers retain the copyright for their performances.

[Source](https://www.youtube.com/watch?v=8aGhZQkoFbQ)

中文简报

Roberts解析浏览器Web API如何在Chrome V8之外实现并发 由于JavaScript引擎严格在单调用栈上执行,开发者必须通过浏览器Web API分流耗时任务,以防止同步代码阻塞渲染循环。 Roberts通过将仅包含单线程调用栈和内存堆的V8引擎,与包含Web API、任务队列和事件循环的外部浏览器架构区分开来,阐明了JavaScript的执行模型。他展示了长时间运行的同步代码如何独占调用栈并卡死UI重绘,并将其与分流任务以保持主线程畅通的异步API进行了对比。事件循环充当协调器,只有在调用栈完全清空后,才会将任务队列中已完成的回调压入栈中。借助其定制的交互式可视化工具Loupe,Roberts阐释了`setTimeout(..., 0)`、16.6毫秒浏览器渲染周期以及对高频事件进行防抖以维持流畅性能的必要性等概念。 核心JavaScript运行时(例如V8)仅包含一个调用栈和一个内存堆;像setTimeout、DOM操作和XMLHttpRequest等关键的异步API均由浏览器环境作为Web API从外部提供。 (2:40) 事件循环充当任务队列与调用栈之间的协调器,只有在调用栈完全清空后,才会将等待中的回调压入栈中。 (12:19) 像setTimeout这样的定时器指定的是最短执行时间而非保证执行时间,这意味着零毫秒定时器只是将执行推迟到当前同步执行完成之后。 (14:55) 浏览器渲染以16.6毫秒(60 fps)为目标间隔,且优先级高于任务队列回调,但同步阻塞操作会彻底阻止重绘,从而导致UI卡死。 (22:15)

精炼阅读摘要

Philip Roberts在JSConf EU演讲中指出,JavaScript引擎本身虽是单线程执行环境,但浏览器通过结合Web API、任务队列与事件循环机制实现了异步并发。他强调,理解这一调度链路对于避免主线程调用栈阻塞及维持流畅的用户界面渲染至关重要。 运行时分工与浏览器协作体系 (2:40) Roberts指出,像Google Chrome的V8这类JavaScript引擎,其内部核心仅包含负责内存分配的堆(Memory Heap)和维护执行帧的调用栈(Call Stack),源码中并不包含setTimeout、DOM操作或XMLHttpRequest等常见功能。JavaScript作为单线程运行时,其调用栈采用后进先出(LIFO)结构,同一时刻只能执行一段代码,无限递归等异常会导致栈溢出并被浏览器强制终止。真正的并发能力源于浏览器整体环境:浏览器提供了独立的Web API线程来承载网络请求、计时器与事件监听,使耗时操作能够脱离JavaScript单线程环境在后台运转,而Node.js中则是通过C++ API实现了对底层线程管理的封装。 事件循环运转与异步调度本质 (12:19) 当Web API处理完后台任务(例如5秒定时器倒计时结束或接收到网络响应)后,不能随意将回调插入正在执行的代码中,而是将其推入任务队列(Task / Callback Queue)。事件循环的核心职责在于持续监控调用栈与任务队列的状态:只要调用栈尚未清空,排队的回调就必须等待;一旦调用栈归零,事件循环便会取出队列头部的回调推入调用栈执行。这一机制解释了setTimeout(fn, 0)并非立即同步执行,而是将任务推入队列以让出当前调用栈,待后续所有同步脚本执行完毕后才触发。因此,定时器设置的毫秒数仅代表回调进入执行状态的最小延迟时间,而非确定性的精准执行时间。 界面渲染瓶颈与队列过载风险 (22:15) 浏览器在无阻塞状态下的目标是以约16.6毫秒的间隔重绘屏幕,以维持60帧每秒的流畅界面体验。然而,只要调用栈被同步的大循环或重量级任务长期占据,浏览器便无法执行重新渲染,也无法响应用户点击或文本选择,导致整个页面冻结。当调用栈清空时,渲染任务的优先级高于普通回调队列,因此通过异步分片(如拆解数组处理循环)交出调用栈,能让浏览器插空完成渲染。此外,UI卡顿不仅由长时间占用栈引起,若对高频触发的滚动(scroll)等DOM事件未作防抖(debounce)处理,任务队列会在极短时间内被数百个排队回调塞满,同样会形成积压进而破坏应用响应性能。 可视化工具Loupe的实现机制 (25:35) 为了向开发者直观呈现这一抽象流程,Roberts开发了名为Loupe的在线可视化工具。该工具通过Esprima语法分析器解析输入的JavaScript代码,在抽象语法树的每个步骤中注入约0.5秒的等待循环以生成慢动作效果。随后,被插桩的代码被置于Web Worker中独立运行,主线程则实时捕获状态,动态渲染函数在调用栈、Web API容器、任务队列以及事件循环之间流转的完整生命周期。 Roberts总结认为,编写高性能前端代码的关键在于不把耗时的慢速代码堆死在调用栈上,并对高频事件合理节流防抖,从而为浏览器渲染和事件循环调度留出处理空间;他在演讲结束时未对其他引擎或微任务队列等更复杂的运行规范做进一步展开。

Detailed notes — zh

## Background 该视频由 JSConf 官方频道于 2014 年 10 月 9 日发布在 YouTube 上,记录了 Philip Roberts 在 JSConf EU 大会上的演讲。页面简介提到,JavaScript 开发者经常挂在嘴边的“事件循环”、“非阻塞”与“单线程”等术语往往让人似懂非懂,本场演讲旨在通过直观的可视化演示与趣味黑客技巧,帮助大家真正建立对 JavaScript 运行机制的直观理解。 ## TL;DR 演讲深入剖析了 JavaScript 作为单线程语言如何在浏览器中实现非阻塞并发的核心奥秘。Philip Roberts 澄清了 V8 引擎仅包含调用栈与内存堆的事实,指出 DOM、AJAX 与 setTimeout 等异步能力实则来自宿主环境的 Web APIs。通过自行开发的可视化工具 Loupe,他生动演示了任务队列与事件循环的协作流程:只有当主调用栈完全清空时,事件循环才会将排队的回调推入执行。最后,演讲探讨了阻塞调用栈对 60 FPS 渲染管线的破坏性影响,并给出了拆分异步长任务与利用防抖(Debounce)优化高频事件的实用建议。 ## Atmosphere & style 整场演讲幽默自嘲、充满活力且启发性极强。Philip Roberts 巧妙地以自身作为资深工程师却对底层概念一知半解的“坦白”切入,瞬间拉近了与台下开发者的心理距离。随着他演示自制可视化工具 Loupe 的动态交互,复杂抽象的底层调度变得极度具象且充满趣味,现场伴随着会心的笑声与豁然开朗的赞叹,给观众带来一种穿透技术黑盒、恍然大悟的爽快感。 ## Bulletin - [01:26](https://www.youtube.com/watch?v=8aGhZQkoFbQ&t=86s) JavaScript 引擎(如 V8)本身仅包含调用栈与内存堆,并不包含 `setTimeout`、DOM API 或事件循环,这些机制均由浏览器宿主环境的 Web APIs 与外部调度系统提供。 - [12:19](https://www.youtube.com/watch?v=8aGhZQkoFbQ&t=739s) 事件循环的核心职责十分单一:持续监控调用栈,仅在调用栈完全清空时,才会将任务队列中的首个回调函数压入栈中执行。 - [14:55](https://www.youtube.com/watch?v=8aGhZQkoFbQ&t=895s) `setTimeout(fn, delay)` 设定的时间并非绝对执行时刻,而仅代表回调进入任务队列的最小等待延迟,`setTimeout(fn, 0)` 的本质是推迟执行直到当前主栈完全清空。 - [22:15](https://www.youtube.com/watch?v=8aGhZQkoFbQ&t=1335s) 浏览器渲染机制约每 16.6 毫秒(60 FPS)请求一次重绘,但无法强行抢占正在运行的 JavaScript 栈帧;任何长耗时同步任务都会直接导致页面掉帧与交互冻结。 ## Key takeaways - [04:16](https://www.youtube.com/watch?v=8aGhZQkoFbQ&t=256s) JavaScript 运行时是单线程的,仅拥有一个调用栈,同一时间只能执行一段代码,进入函数入栈、返回出栈,无限递归会导致调用栈溢出(爆栈)。 - [01:26](https://www.youtube.com/watch?v=8aGhZQkoFbQ&t=86s) V8 引擎源码中不存在 `setTimeout`、AJAX 或 DOM 操作代码,异步并发能力完全来自浏览器提供的外部 Web APIs(在 Node.js 中对应 C++ APIs)。 - [07:18](https://www.youtube.com/watch?v=8aGhZQkoFbQ&t=438s) 长时间占用调用栈的慢速同步代码(如复杂的 `while` 循环)会彻底阻塞浏览器,导致页面失去响应、交互搁置且无法重新渲染。 - [12:19](https://www.youtube.com/watch?v=8aGhZQkoFbQ&t=739s) Web APIs 运行在后台独立线程中处理计时或网络请求,并在完成后将对应的回调推入任务队列,绝对无法直接插手或篡改调用栈。 - [14:55](https://www.youtube.com/watch?v=8aGhZQkoFbQ&t=895s) 事件循环在调用栈变空之前绝不会从任务队列中调度任何任务,因此所有同步代码永远优先于排队的回调函数执行完。 - [14:55](https://www.youtube.com/watch?v=8aGhZQkoFbQ&t=895s) `setTimeout(..., 0)` 并不能实现即时运行,而是作为一种代码延迟执行技巧,确保某些逻辑在调用栈彻底出栈后再执行。 - [20:16](https://www.youtube.com/watch?v=8aGhZQkoFbQ&t=1216s) 回调函数存在同步与异步之分:`Array.prototype.forEach` 是完全同步执行并占满调用栈的,而通过定时器拆分的异步回调才会进入任务队列分批调度。 - [22:15](https://www.youtube.com/watch?v=8aGhZQkoFbQ&t=1335s) 浏览器的界面渲染拥有比普通任务队列更高的优先级,但它同样必须排队等待调用栈清空后才能执行界面绘制。 - [22:15](https://www.youtube.com/watch?v=8aGhZQkoFbQ&t=1335s) 高频触发的 DOM 事件(如滚动 `scroll`)如果未做防抖或节流处理,会导致大量回调瞬间淹没任务队列,形成严重的渲染排队卡顿。 - [25:58](https://www.youtube.com/watch?v=8aGhZQkoFbQ&t=1558s) 可视化演示工具 Loupe 借助 Esprima 语法解析器在代码关键节点注入耗时 `while` 循环以实现慢动作,并放入 Web Worker 独立运行避免冻结主界面。 ## Detailed walkthrough ### [00:01](https://www.youtube.com/watch?v=8aGhZQkoFbQ&t=1s) 演讲开场与一个困惑已久的疑问 主持人向大家介绍菲利普·罗伯茨(Phillip Roberts),他任职于专门从事实时开发的小型咨询公司 &yet(AndYet),来自苏格兰爱丁堡。菲利普登台后,看到分会场座无虚席感到非常兴奋,并打趣地让台下所有人跟他一起伸个懒腰,好让自己看起来不那么奇怪。 菲利普随后直奔主题,谈起这次演讲的核心命题:“事件循环(Event Loop)到底是个什么鬼东西?”他坦言,大约在 18 个月前,自己虽然已经是一名拿薪水的全职专业 JavaScript 开发者,但内心深处却产生了一个疑问:JavaScript 究竟是如何运转的?在当时,他对底层的很多概念其实一知半解。他常听人提起 V8、Chrome Runtime 之类的词汇,却根本不知道它们具体负责什么;他也知道 JavaScript 是“单线程”的,也一直在写回调函数,但他搞不懂回调函数到底是怎么运行的。这促使他开启了一段阅读、研究并在浏览器中动手实验的探索之旅。 ### [01:26](https://www.youtube.com/watch?v=8aGhZQkoFbQ&t=86s) 寻找答案的死胡同与完整的浏览器架构 菲利普幽默地模拟了自己当时与 JavaScript 的对话。当他问 JavaScript“你到底是什么”时,得到的教科书回答是:“我是单线程单并发语言,我有一个调用栈(Call Stack)、一个事件循环(Event Loop)、一个回调队列(Callback Queue)以及一些其他 API”。由于菲利普并没有计算机科学学位,这些术语听起来既抽象又令人困惑。于是他转向 Chrome 的 JavaScript 引擎 V8 寻求答案,以为能从中找到所有这些组件,结果翻看 V8 源码时才发现,V8 基本上只有调用栈和用于内存分配的堆(Memory Heap)。关于事件循环、回调队列或者其他 API,V8 里根本不存在。 更让他震惊的是,当他在 V8 源码中查找日常开发中最常见的异步要素(如 `setTimeout`、DOM 操作或 HTTP 请求)时,竟完全找不到这些东西的踪影。正如菲利普所总结的:“It's first thing you use when you start thinking about async stuff and it's not in the V8 source.” 经过长达 18 个月的摸索,他终于拼凑出了全局图景:V8 等运行时仅仅是整个生态的一部分,浏览器还提供了额外的 Web API(包括 DOM、AJAX、计时器等),而在它们之间穿针引线的,正是看似神秘的事件循环和任务/回调队列。 ```mermaid flowchart TD accTitle: 浏览器环境完整架构图 accDescr: 展示 JavaScript 运行时、Web API、回调队列与事件循环之间的协作关系 subgraph Runtime["JavaScript 运行时 (例如 V8)"] Heap["内存堆 (Heap)<br/>内存分配"] Stack["调用栈 (Call Stack)<br/>执行帧 / 单线程"] end subgraph Browser["浏览器宿主环境"] WebAPIs["Web APIs<br/>DOM, AJAX, setTimeout..."] Queue["回调队列 (Callback Queue)<br/>onClick, onLoad, onDone..."] EventLoop["事件循环 (Event Loop)"] end Stack -.->|"调用 Web API"| WebAPIs WebAPIs -.->|"任务完成推入"| Queue Queue -.->|"被调度送回"| EventLoop EventLoop -.->|"栈清空时压入"| Stack ``` ### [04:16](https://www.youtube.com/watch?v=8aGhZQkoFbQ&t=256s) 单线程与调用栈(Call Stack)的运作机制 菲利普从最基础的机制讲起,深入剖析了 JavaScript 的单线程本质。所谓单线程运行时,意味着它只有一个调用栈,同一时间只能做一件事。为了具象化这个概念,他用一段简单的代码进行演示:一个将两个数字相乘的 `multiply` 函数、一个调用乘法计算平方的 `square` 函数,以及一个调用 `square` 并打印结果的 `printSquare` 函数。 调用栈本质上是一种记录程序当前运行位置的数据结构:进入一个函数就将其压入栈顶(push),从函数返回时就从栈顶弹出(pop)。当文件开始执行时,首先入栈的是代表整个脚本的 `main` 函数;随后执行到 `printSquare(4)`,将其推入栈中;在 `printSquare` 内部调用了 `square(4)`,再次入栈;`square` 又调用了 `multiply(4, 4)` 进栈;`multiply` 计算完成后执行 `return`,该函数出栈;接着 `square` 返回出栈;随后调用栈执行 `console.log` 输出结果并完成;最后 `printSquare` 运行完毕并随同主文件退出栈,整个调用栈归零。 菲利普指出,哪怕开发者以前没有刻意关注过调用栈,在平时调试浏览器代码时也肯定接触过。例如,当一个嵌套调用的函数抛出未捕获的错误时,Chrome 控制台打印出的调用栈轨迹(Stack Trace)清晰展示了崩溃时栈内的逐层状态:`Foo`、`Bar`、`Baz` 以及最外层的匿名主函数 `main`。类似地,如果编写一个无限递归调用自身的 `foo` 函数,调用栈就会被不断塞满,直到 Chrome 抛出“RangeError: Maximum call stack size exceeded”(即所谓的爆栈 Blow the stack),自动终止程序以防止崩溃。 - **调用栈的作用**:记录当前代码执行到了哪一步。 - **基本操作行为**:进函数 push 入栈,遇 return 或执行完毕 pop 出栈。 - **调用栈溢出(Blowing the stack)**:递归无终止条件导致超出栈容量,浏览器通常在达到约 16,000 次调用时主动报错中断。 ### [07:18](https://www.youtube.com/watch?v=8aGhZQkoFbQ&t=438s) 为什么代码会阻塞?同步带来的浏览器灾难 既然 JavaScript 只有一个线程和一个调用栈,那么当操作变慢时会发生什么?菲利普讨论了阻塞(Blocking)的概念。虽然技术上对什么是阻塞没有严格的唯一定义,但简而言之,任何慢速的代码都会造成阻塞。`console.log` 不慢,但执行一个从 1 数到 100 亿的 `while` 循环就会慢,网络请求、图像加载同样十分缓慢。当这些耗时很长的操作霸占在调用栈上时,就是所谓的阻塞行为。 为了直观展示这一点,菲利普假设如果 AJAX 网络请求是同步的(比如伪代码中的 `getSynchronous`),会发生什么局面:程序调用同步请求后必须干等(Wait),直到请求完成才能执行下一步;随后再发一个请求,继续干等。如果网络出现故障,请求永远无法完成,程序就彻底被挂起。 随后菲利普在屏幕上打开 Chrome 进行了现场演示。由于在浏览器中模拟同步请求比较繁琐,他用一个空转 5 秒钟的庞大 `while` 循环伪装成同步网络请求。当他点击“Run”按钮执行这段代码时,灾难发生了: 1. 页面完全失去响应,甚至 Run 按钮的点击重绘状态都无法完成渲染。 2. 开发者在界面上的任何点击操作均被搁置,浏览器陷入彻底的“假死”冻结状态。 3. 菲利普对此生动地描述道:“The browser is blocked, it's stuck, it can't do anything until those requests complete.” 4. 直到 5 秒的同步执行彻底结束,之前积压的用户交互操作才一口气爆发出来。 菲利普强调,这正是单线程在浏览器端面临的最大痛点:只要调用栈上有代码在执行,浏览器就无法重新渲染界面,也无法响应任何其他事件。如果想让用户获得丝滑流畅的 UI 交互,就绝对不能阻塞调用栈。 ### [10:22](https://www.youtube.com/watch?v=8aGhZQkoFbQ&t=622s) 异步回调与并发魔法的揭秘 为了解决调用栈阻塞的问题,JavaScript 给出的核心方案是异步回调(Asynchronous Callbacks)。无论在浏览器端还是 Node.js 环境中,绝大部分底层任务都被设计成异步的:调用某个函数,传入一个回调函数,稍后再去执行它。 菲利普给出了一个极其经典的测试样例: 1. `console.log('hi')` 2. `setTimeout(function cb() { console.log('there'); }, 5000)` 3. `console.log('JSConfEU')` 按照调用栈的直觉理解,先打印出 `hi`,然后遇到 `setTimeout`。我们知道传给它的回调不会立刻执行,而是要在 5 秒后触发,但它显然无法一直停留在调用栈上占位。神奇的是,`setTimeout` 瞬间就从调用栈上消失了,接着代码毫无停滞地执行并打印出 `JSConfEU`,调用栈被完全清空。而在整整 5 秒钟之后,回调函数仿佛被施了魔法一样凭空回到了调用栈中,打印出 `there`。 这种“消失又出现”的现象究竟是如何做到的?菲利普在此揭开了演讲的核心真相:“Right, so I've been kind of partially lying to you and telling you that JavaScript can only do one thing at one time.” 他解释道,虽然 JavaScript 运行时(如 V8)本身确实同一时刻只能做一件事,既不能在跑业务逻辑的同时发网络请求,也不能在执行代码的同时做定时等待,但浏览器本身绝不仅仅只有 JavaScript 运行时。浏览器提供的 Web API 具备真正的多线程并发能力,而事件循环正是协调这些组件协同工作的关键纽带。 ### [12:19](https://www.youtube.com/watch?v=8aGhZQkoFbQ&t=739s) 浏览器的 Web APIs、任务队列与事件循环的核心职责 浏览器并不仅包含 V8 这样的单一 JavaScript 运行时,它还额外提供了许多被称为 Web APIs 的底层能力。这些 Web APIs 本质上是浏览器在后台开启的线程,开发者只需在 JavaScript 中调用它们,并发处理(concurrency)便由此介入。Philip Roberts 指出,如果你是后端开发者,Node.js 的内部架构图与此基本相同,只不过浏览器端的 Web APIs 在 Node 端被替换成了 C++ APIs,多线程的复杂性全部被封装在了 C++ 背后。 当 JavaScript 执行 `setTimeout(callback, delay)` 时,该 API 并不存在于 V8 引擎内部,而是浏览器运行时提供的外部扩展。浏览器会为此接管倒计时任务。此时,调用栈中的 `setTimeout` 本身已经执行完毕并立即出栈(Pop),主线程得以继续向下执行后续代码(例如打印 `"JSConfEU"`)。当五秒倒计时结束后,Web API 并不能直接把回调函数扔回调用栈里,否则这些代码就会毫无预兆地随机插入到正在执行的主流程中。为了保证执行的可预测性,Web API 在完成任务后会将回调函数推入“任务队列”(Task Queue,亦称 Callback Queue)。 至此,演讲的主角——事件循环(Event Loop)登场。Philip Roberts 说明:“The event loops job is to look at the stack and look at the task queue. If the stack is empty it takes the first thing on the queue and pushes it on to the stack which effectively run it.”(事件循环的工作就是看着调用栈,同时看着任务队列;一旦调用栈变空,它就取出任务队列中的第一项并推入调用栈,从而让它执行)。只有当主栈完全清空后,事件循环才会将队列中的回调推回 V8 的执行栈中,回调里的 `console.log("there")` 才能最终完成打印。 ```mermaid flowchart LR accTitle: JavaScript 运行时与事件循环架构 accDescr: 展示调用栈、Web APIs、任务队列以及事件循环之间协同工作的流程图。 subgraph Runtime["JavaScript 运行时 (V8)"] Stack["调用栈 (Call Stack)"] end subgraph Browser["浏览器环境"] WebAPIs["Web APIs\n(Timer / DOM / AJAX)"] Queue["任务队列 (Task Queue)"] end Stack -->|"调用异步 API"| WebAPIs WebAPIs -->|"计时/网络完成"| Queue Queue -.->|"栈清空时出队推入"| Loop(("事件循环\nEvent Loop")) Loop -.->|"推入执行"| Stack ``` - `setTimeout` 并非 V8 源码的一部分,而是由运行环境(浏览器或 Node.js)提供的外部 API。 - Web APIs 在后台独立线程处理计时或网络请求,倒计时结束后仅将回调注入任务队列,不能直接篡改调用栈。 - 事件循环的角色极其纯粹且单一:不断检测调用栈是否为空,若为空且队列中有排队任务,便将首个回调压入调用栈。 --- ### [14:55](https://www.youtube.com/watch?v=8aGhZQkoFbQ&t=895s) 解密 `setTimeout(fn, 0)` 与通用异步 API 机制 初学异步 JavaScript 时,开发者常常会遇到要求编写 `setTimeout(fn, 0)` 的古怪建议。很多人第一反应都是大惑不解:既然要等待 0 毫秒立即执行,为何还要特意包一层 `setTimeout`?Philip Roberts 坦言,自己第一次见到这种写法时也是一头雾水:“The reason is, generally, if you're trying to defer something until the stack is clear.”(其原因通常在于,你试图将某些操作推迟到调用栈完全清空之后再执行)。 即使延迟设定为 0 毫秒,浏览器的 Web API 也会立即将回调放入任务队列。然而,由于事件循环必须严格等待当前的调用栈全部清空,后续的同步代码(如打印 `"hi"`、`"JSConfEU"`)依然会优先在主栈中跑完。直到主线程代码全部出栈,事件循环才介入并将排队的回调推上调用栈。 所有异步 Web APIs 都遵循完全相同的模式。以常见的 AJAX 请求为例,发起请求时传入回调与目标 URL,具体执行网络传输的代码并不在 JavaScript 运行时里,而是在浏览器的 Web API 线程池中转动。在此期间,主调用栈无需等待网络返回,可以顺畅执行后续代码;甚至即使 XHR 请求失败或永远没有响应,主栈也不会挂起。一旦请求成功返回,回调即被推入队列,等待事件循环在空闲时拉取执行。 - `setTimeout(..., 0)` 并不能实现真正的“即刻运行”,而是实现代码执行的延迟(Defer),强制其排在当前调用栈全部出栈之后。 - 异步 AJAX 请求将繁重的 I/O 等待卸载到浏览器宿主环境,使单线程 JavaScript 能够持续响应。 --- ### [16:58](https://www.youtube.com/watch?v=8aGhZQkoFbQ&t=1018s) 演示工具 Loupe 的诞生与真实交互队列观察 为了直观展示复杂的执行流程,Philip Roberts 原本在 Keynote 幻灯片里手工制作了大约 500 个极其繁琐的动画步骤。但在苏格兰 JS 大会(Scotland JS)后,幻灯片坏了一半,重新在 Keynote 里排版调整极其痛苦。于是,他选择了一条幽默的“偷懒”捷径——索性自己动手写了一套名为 Loupe 的可视化工具,在运行时实时模拟 JavaScript 运行时、Web APIs、任务队列与事件循环的动态流转。 在 Loupe 中运行包含 DOM 点击监听(`addEventListener`)和 `setTimeout` 的代码,可以清晰看到调用栈如何迅速消费同步逻辑,并将事件监听注册到 Web APIs 区块。当用户在页面上点击按钮时,Web API 立即触发并将对应的点击回调推入任务队列。如果快速连续点击按钮 100 次,这些点击事件并不会立刻穿透到 JavaScript 引擎执行,而是全数堆积在任务队列中排队。主栈在处理完当前指令后,由事件循环逐个将点击回调拉入栈中处理。 这进一步揭示了计时器的真实语义。如果连续调用 4 次延迟为 1 秒的 `setTimeout` 并紧随一个同步的打印,当第四个定时器在 Web API 中到期并排入任务队列时,由于前面有正在等待或执行的回调,第四个回调实际被调用的时间必然远远超出设定的 1 秒。Philip Roberts 强调指出:“...it's not a guaranteed time to execution, it's a minimum time to execution, just like setTimeout zero doesn't run the code immediately it runs the code next‑ish, sometime, right?”(……它并不是保证执行的时间点,而是一个最小执行延迟;就像 `setTimeout` 设为 0 并不会马上执行代码,而是在接下来的某个时刻执行,对吧?)。 - Loupe 是作者为了规避 Keynote 繁复动画制作而开发的可视化调试与教学工具。 - 用户交互(如点击事件)在宿主层触发后,必须转化为队列中的任务,按先进先出顺序等待调度。 - `setTimeout(fn, delay)` 中的 `delay` 仅代表回调进入任务队列的最小等待时间,绝非精确的执行时刻保证。 --- ### [20:16](https://www.youtube.com/watch?v=8aGhZQkoFbQ&t=1216s) 同步回调与异步回调的辨析 在日常技术讨论中,“回调”(Callback)一词经常引发概念混淆。Philip Roberts 澄清,回调在语境中通常包含两种含义:广义上指代“任何被另一个函数调用的函数”;而在异步编程的严格语境下,则特指“未来会被推入回调队列的异步函数”。 以数组内置的 `forEach` 方法为例,虽然它接受一个函数参数并习惯被称为回调,但它完全是同步执行的,每一个迭代调用都直接堆叠在当前调用栈中,牢牢霸占主线程,直到整个数组遍历结束才让出。如果手动封装一个利用 `setTimeout(..., 0)` 实现的异步版 `asyncForEach`,行为则截然不同:它在循环中迅速将每一次处理包装为异步任务投递到 Web APIs 和任务队列,从而迅速清空当前的同步栈,使后续的同步输出能够立刻执行,之后再由事件循环逐个消化各元素的回调。 ```javascript // 同步 forEach:回调直接在当前调用栈中执行,阻塞主线程 [1, 2, 3, 4].forEach(function(i) { console.log(i); }); // 异步 forEach:利用异步 API 将每次执行推迟到任务队列 function asyncForEach(array, cb) { array.forEach(function(item) { setTimeout(function() { cb(item); }, 0); }); } ``` - 同步回调(如原生 `Array.prototype.forEach`)同步占用调用栈,栈未执行完前外部代码完全停滞。 - 异步回调借助调度机制解耦,各迭代项作为独立任务排入任务队列,分批次被调用栈执行。 --- ### [22:15](https://www.youtube.com/watch?v=8aGhZQkoFbQ&t=1335s) 浏览器渲染管线、掉帧与“不要阻塞事件循环” JavaScript 的单线程机制对浏览器的渲染管线(Render Pipeline)有着决定性的制约。理想状态下,为了呈现流畅的用户界面,浏览器期望以每秒 60 帧(60 FPS)的速率重绘屏幕,也就是大约每 16.6 毫秒就要执行一次重绘(Repaint/Render)。然而,只要当前 JavaScript 调用栈中有任何代码正在运行,浏览器就无法插入渲染流程。渲染流程在行为上类似于一个拥有更高优先级的特殊回调:它大约每 16 毫秒就会发起一次重绘请求,但前提是必须静候调用栈彻底清空。 Philip Roberts 现场展示了他在演示工具中加入的重绘模拟机制。当主线程运行耗时严重的同步循环处理时,渲染队列被彻底锁死。在重绘受阻的这段时间里,用户在屏幕上无法选中文本,点击按钮没有任何视觉反馈,页面呈现死锁状态。相反,如果将耗时计算拆解为异步批处理,虽然在推入定时器时会有极短暂的微小占用,但在每次处理元素之间,调用栈都会清空,从而让浏览器的渲染机制有机会穿插进来完成界面绘制。 谈及社区常说的性能箴言,Philip Roberts 总结道:“They're saying don't put shitty slow code on the stack because when you do that the browser can't do what it needs to do, create a nice fluid UI.”(他们是在说,不要把又烂又慢的代码往栈上扔,因为一旦你这么做了,浏览器就无法完成它该做的工作——打造一个丝滑流畅的用户界面)。不仅低效的同步运算会阻塞调用栈,不加节制的事件处理同样会拖垮系统。例如 DOM 中的滚动事件(`scroll`)在滑动时会高频触发(甚至达到每 16 毫秒触发一次)。如果在 `document.scroll` 的回调中绑定沉重复杂的动画或运算,虽然单次调用并没有长期占死栈空间,但海量的回调会像洪水一样瞬间淹没任务队列(Flooding the queue),造成灾难性的排队卡顿。 - 浏览器理想刷新频率为 60 FPS(每帧约 16.6ms),任何驻留在调用栈中的长任务都会直接推迟重绘并引发掉帧。 - 渲染调度虽然比普通任务队列中的异步回调拥有更高优先级,但依然无法强行抢占(Preempt)正在执行的 JavaScript 栈帧。 - 高频触发的事件(如滚动、手势等)如果未做防抖或节流,会导致任务队列泛滥积压,形成严重的界面滞后。 ### [25:35](https://www.youtube.com/watch?v=8aGhZQkoFbQ&t=1535s) 防抖优化与事件循环的实际应用 在处理诸如滚动(scroll)事件等会高频触发的回调函数时,很容易导致调用栈和任务队列被严重阻塞,进而引发界面卡顿。Philip Roberts 指出,面对这种情况可以通过防抖(debounce)技术来进行性能优化。这种方案的核心思想在于对事件进行排队和合并控制,避免每一次触发都立即执行耗时的复杂计算,而是“每隔几秒钟执行一次慢速任务,或者直到用户停止滚动一段时间后再执行”。通过这种控制执行节奏的方式,可以保证页面响应灵敏,不会因为大量回调堆积而直接卡死浏览器的渲染通道。 ```mermaid flowchart TD accTitle: 事件防抖机制 accDescr: 展示高频触发事件如何通过防抖机制合并处理,以避免阻塞调用栈。 subgraph Trigger["高频触发阶段"] E1["滚动事件 1"] E2["滚动事件 2"] E3["滚动事件 N"] end subgraph Control["防抖控制层"] D["Debounce 调度"] end subgraph Exec["执行阶段"] W["执行耗时计算任务 / 渲染"] end E1 --> D E2 --> D E3 --> D D -->|"用户停止滚动后 / 间隔触发"| W ``` ### [25:58](https://www.youtube.com/watch?v=8aGhZQkoFbQ&t=1558s) 可视化演示工具的实现幕后与结语 为了向观众清晰展示事件循环的内部运行机制,Philip Roberts 自制了一款专门的可视化工具(即著名的 Loupe)。在演讲接近尾声时,他笑着向大家揭秘了该工具在底层究竟是如何实现“慢动作”动画效果的。他坦言这套工具的实现细节非常丰富,直言:“There's a whole other talk in how the hell this works.” 这段代码之所以能够在页面上以极慢的节奏逐步呈现,是因为它在运行时被动态处理了:程序首先会通过 JavaScript 语法解析器 Esprima 对输入的代码进行解析和语法分析,随后在代码的关键节点之间硬编码插入一个耗时约半秒的大型 `while` 循环,从而人工为代码执行加上“慢动作放慢滤镜”。紧接着,代码会被派发到 Web Worker 中运行,并配合大量的前端交互与状态捕捉逻辑,实时还原调用栈、Web API、任务队列与事件循环之间的协同状态。Philip Roberts 表示自己对这个工具的实现机制感到非常兴奋,并热情邀请对技术细节感兴趣的参会者在演结束后与他线下交流。 - **解析与插桩**:利用 JavaScript AST 解析器 Esprima 解析用户编写的代码,并在代码执行路径中注入耗时约半秒的 `while` 循环来实现慢镜头执行效果。 - **后台隔离**:将经过处理的代码交由 Web Worker 独立执行,以此在不冻结主界面渲染的前提下实时监控运行状态并生成可视化视图。 ## Notable quotes > [12:19](https://www.youtube.com/watch?v=8aGhZQkoFbQ&t=739s) The event loops job is to look at the stack and look at the task queue. If the stack is empty it takes the first thing on the queue and pushes it on to the stack which effectively run it. — Philip Roberts > [22:15](https://www.youtube.com/watch?v=8aGhZQkoFbQ&t=1335s) They're saying don't put shitty slow code on the stack because when you do that the browser can't do what it needs to do, create a nice fluid UI. — Philip Roberts ## Mentioned Philip Roberts, JSConf EU, &yet, JavaScript, Chrome, V8, Node.js, Loupe, Keynote, Scotland JS, Esprima, Web Worker ## Video description JavaScript programmers like to use words like, “event-loop”, “non-blocking”, “callback”, “asynchronous”, “single-threaded” and “concurrency”. We say things like “don’t block the event loop”, “make sure your code runs at 60 frames-per-second”, “well of course, it won’t work, that function is an asynchronous callback!” If you’re anything like me, you nod and agree, as if it’s all obvious, even though you don’t actually know what the words mean; and yet, finding good explanations of how JavaScript actually works isn’t all that easy, so let’s learn! With some handy visualisations, and fun hacks, let’s get an intuitive understanding of what happens when JavaScript runs. Transcript: http://2014.jsconf.eu/speakers/philip-roberts-what-the-heck-is-the-event-loop-anyway.html License: For reuse of this video under a more permissive license please get in touch with us. The speakers retain the copyright for their performances. [Source](https://www.youtube.com/watch?v=8aGhZQkoFbQ)

Source quotes

[12:19] Philip Roberts: The event loops job is to look at the stack and look at the task queue. If the stack is empty it takes the first thing on the queue and pushes it on to the stack which effectively run it. [22:15] Philip Roberts: They're saying don't put shitty slow code on the stack because when you do that the browser can't do what it needs to do, create a nice fluid UI.