你的代码到底什么时候跑?JavaScript 事件循环实战指南
JavaScript 一次只跑一件事,顺序不是凭感觉猜的。本文按 MDN 的《JavaScript 执行模型》与《使用微任务》讲清楚:堆、队列、栈,一个任务再清空微任务,微任务为什么插队,长任务怎么卡住页面,以及 queueMicrotask 的两个正经用途。

先把这篇的边界说清楚。站里已经有《Promise 与 async/await 实战指南》,讲的是等一个结果回来有几种写法;这篇不讲写法,讲的是时间:代码到底什么时候跑,先跑谁、后跑谁、谁能插队、谁会卡住页面。还有一篇《闭包与作用域实战》,讲的是变量能活多久、谁能看见它;这篇不讲变量的命,只讲执行的顺序。下面用到的“灯塔书店”是一个虚构的练手项目:一个帮街边书店做点单的网页小工具,顾客搜书、下单、付款,程序先查库存、再算运费、最后提交订单。本文所有以它为例的操作、代码和数字,都是为了讲清楚做法编出来的,不是真实记录。所有关于事件循环、任务与微任务的说法,都来自 MDN 的《JavaScript 执行模型》参考页与《使用微任务》指南,来源见每篇的 meta 信息与 evidence 记录。MDN 文档里的例子,比如 foo、bar、baz 的调用栈、1 和 2 的输出顺序、10 的阶乘,都是文档自带的示例,不是真实用户数据。
第一步:JavaScript 是单线程的,卡住就全卡住
JavaScript 的执行模型,第一句话就是:一个代理就是一个线程,解释器一次只能处理一条语句。代理是规范里的说法,对应一个执行 JavaScript 的线程;浏览器里的每个窗口、每个 Worker,都有自己的代理。单线程的意思是:同一时间,只有一段代码在跑。代码全是同步的时候,这没什么问题,因为总能往前走。可一旦代码要做异步的事,比如等网络回来、等用户点一下鼠标,程序就不能停在原地等——JavaScript 作为网页脚本语言,要求它永远不阻塞。MDN 的原话是:代码要处理异步动作的完成,就定义成回调,这个回调定义了一个任务,等动作完成之后放进任务队列。
“永远不阻塞”不是说代码跑得快,而是说等结果的时候不占着线程。等 fetch 回来、等 IndexedDB 查完,页面照样能处理用户的输入,因为“等”这件事本身不跑代码,跑代码的是动作完成之后被放进队列的那个回调。反过来说,正在跑的代码是没人能打断的:一个函数一旦开始跑,就一口气跑完,别的代码只能等它跑完。这就是事件循环模型的核心约定,也是后面所有时序问题的前提。
第二步:引擎和宿主环境,两件套配合干活
JavaScript 的执行,需要两件软件配合:JavaScript 引擎和宿主环境。引擎实现 ECMAScript 语言本身,负责解析源码、执行代码;宿主环境提供和外界打交道的机制,比如浏览器里的 HTML DOM,或者服务器端的 Node.js。引擎管语言,宿主环境管外界:定时器、网络请求、用户点击,这些都是宿主环境提供的。MDN 还提醒:规范里偶尔会讲到 HTML 规范定义的机制,Node.js、Deno 这些宿主环境也常常照着 HTML 的做法来,所以这套执行模型在网页之外也大体适用。
分清这两件套有什么用?写代码的时候,setTimeout、fetch、addEventListener 这些都不是语言本身的东西,是宿主环境给你的。它们的行为——比如定时器到点之后回调被放进哪个队列——由宿主环境和规范共同决定。语言只规定“函数怎么跑”,宿主环境决定“什么时候轮到它跑”。
第三步:堆、队列、栈——三件套各管各的
每个代理维护三样东西。第一样是堆,英文叫 heap:一大块没什么结构的内存,对象创建出来就往里放。第二样是队列,英文叫 queue:在 HTML 里就叫事件循环,让 JavaScript 在单线程的前提下还能写异步程序。队列一般是先进先出:先进来的任务先执行。第三样是栈,英文叫 stack:也就是调用栈,靠进出执行上下文来移交控制权。栈是后进先出:每个任务开始时把一个新帧压进空栈,任务结束时把栈清空。
三样东西各管各的,别混在一起:堆管对象活在哪,栈管函数正在跑到哪,队列管下一个该跑谁。很多时序问题,根子上就是把这三样弄混了:以为对象在堆里就等于代码在跑,或者以为函数进了栈就等于任务完成了。记住分工:栈空了,一个任务才算跑完;队列空了,代理就等着,等新的任务被加进来。
第四步:调用栈——函数一层压一层,跑完一层弹一层
先看同步代码是怎么跑的。MDN 的例子是三个函数:foo 接受 b,里面 const a 等于 10,返回 a 加 b 加 11;bar 接受 x,里面 const y 等于 3,返回 foo(x 乘 y);最后 const baz 等于 bar(7),baz 是 42。算一遍:bar(7) 里 x 是 7,y 是 3,x 乘 y 是 21,foo(21) 里 a 是 10,b 是 21,10 加 21 加 11 等于 42。没错,baz 就是 42。
跑的过程是:任务开始,先建第一个帧,里面定义了 foo、bar、baz,调用 bar(7),压进第二个帧,里面有参数 x 和局部变量 y,算出 21,调用 foo,压进第三个帧,里面有参数 b 和局部变量 a,算出 42,返回。foo 返回,顶上的帧弹出,调用表达式变成返回值;bar 返回,再弹出一个帧,baz 被初始化成 42;任务源码跑到头,入口帧弹出,栈空了,这个任务就算完成了。执行上下文是执行的最小单位,记录着代码跑到哪、属于哪个模块或者函数、当前是哪个生成器、有哪些变量绑定,还有 this 是谁。帧弹出不等于永远消失:生成器函数就是反例,调用 gen() 只建一个被挂起的执行上下文,代码一行都没跑;调一次 g.next() 打印 1,再调一次打印 2,上下文被推上去、挂起、再推上去,接着上次停的地方继续跑。
第五步:一轮事件循环,先跑一个任务,再清空微任务
同步代码讲完了,异步代码的规矩是:每个任务从队列里取出来、跑完,跑的过程中可能产生更多任务,排到队尾;任务可能由异步平台机制的完成而加入,比如定时器、输入输出、事件。一个任务被认为完成的时候,栈是空的,然后才取下一个任务。HTML 的事件循环把任务分成两类:任务和微任务。微任务优先级更高,微任务队列要先排空,才轮到任务队列。
MDN 的《使用微任务》指南把一轮循环的顺序写得很清楚:事件循环一次处理任务队列里最老的那个可运行任务;这个任务退出之后,执行微任务,直到微任务队列为空;然后浏览器可能更新渲染;再进入下一轮事件循环。也就是说,一轮循环是三步:一个任务,清空微任务,可能渲染。渲染不是每轮都有,浏览器“可能”更新渲染;但微任务是每轮必清空的。记住这个顺序,后面所有“为什么先打印这个”的问题,答案都在这三步里。
第六步:微任务会插队,递归微任务会饿死渲染
任务和微任务看着像,但处理方式有两点关键区别。第一,每次任务退出、控制权要交回给别的 JavaScript 代码的时候,事件循环都会检查并跑掉微任务队列里的全部微任务,所以微任务队列在一轮循环里会被处理多次,包括处理事件和其他回调之后。第二,如果一个微任务又往队列里加了微任务,新加的微任务会在下一个任务跑之前执行,因为事件循环会一直调微任务,直到队列里一个都不剩,哪怕新的还在不断加进来。
第二点就是危险所在。MDN 直接给了警告:微任务自己可以再排微任务,事件循环会一直处理微任务直到队列为空,所以存在事件循环永远在处理微任务的风险,递归加微任务的时候要小心。一个不停往里加微任务的循环,会让后面的任务永远排不上,渲染也永远等不到,页面看起来就像死了一样。微任务不是“更快”的任务,它是“插队”的任务;插队插得太多,后面排队的人就永远等不到。微任务只用在没有别的办法的时候,或者写框架、写库需要它的时候,别拿它当常规工具。
第七步:先记住 1、2、3、4 这组数字
时序问题最适合用数字背下来。MDN 的 Promise 指南里有一组:Promise.resolve().then 打印 2,然后 console.log(1),输出永远是 1、2。因为 then 的回调被放进了微任务队列,要等当前同步代码跑完、执行栈空了才跑。执行模型那篇给了更完整的版本:wait(0).then 打印 4,接着两个 then 分别打印 2 和 3,最后 console.log(1),输出是 1、2、3、4。微任务先于定时器任务执行,所以同样是等 0 毫秒,Promise 的回调比 setTimeout 的回调先跑。
微任务指南里还有一组对照:先打“主程序开始”,再 setTimeout 0 毫秒排一个普通回调,再 queueMicrotask 排一个紧急回调,最后打“主程序退出”。输出是:主程序开始、主程序退出、紧急回调、普通回调。主程序的输出先出现,然后是微任务,最后才是定时器的回调,因为主程序那个任务退出的时候,微任务队列先被处理,定时器回调所在的任务队列排在后面。记住一句话就能分清两者:任务和微任务分属不同的队列,微任务先跑。setTimeout 0 毫秒不是“立刻跑”,是“排到任务队尾,等下一轮”;queueMicrotask 才是“这轮任务一结束就跑”。
第八步:每个任务跑完才换下一个,顺序才可预测
事件循环模型有一个很好的性质:每个任务都会完整处理完,别的任务才开始处理。这意味着一个函数一旦开始跑,就不会被抢占,会一口气跑完再让别的代码跑。MDN 的例子是:先 Promise.resolve(),再 let i 等于 0,然后两次 promise.then,每次都把 i 加 1 再打印。看起来像竞态,输出却完全可预测:1,然后 2。因为每个任务跑完才换下一个,所以整体顺序永远是 i 加 1、打印 i、i 加 1、打印 i,绝不会是两次加 1 再两次打印。
这个保证是推理程序的底气:函数里改了一半的数据,不会被别的代码在中途看见。但它也有代价:如果一个任务跑得太久,网页就处理不了点击、滚动这些用户交互。浏览器会用“脚本跑得太久”的提示来缓解,但治本的办法是:让每个任务的处理尽量短,太长的任务切成几个小任务。长任务不是“跑得慢”,是“占着线程不放”,占着线程,队列里排队的点击回调就只能干等。
第九步:长任务卡页面,切小了再排队
灯塔书店的搜书页就能说明这件事。假设搜书结果有几千条,一次性在同一个任务里全渲染出来,页面要卡好几秒,这几秒里点什么都没反应。修法是切小:一次只渲染 50 条,渲染完用 setTimeout 0 毫秒或者 requestAnimationFrame 把剩下的排到下一个任务,中间让出线程,用户的点击和滚动就能插进来。切小不是变慢,是把一次长等待拆成多次短等待,每次短等待之间,页面都能喘口气。
这里要分清两种“等”:等网络、等用户输入,是不占线程的等;跑一个几秒钟的循环,是占着线程的等。前者是事件循环本来就要处理的事,后者是写代码的人自己造出来的长任务。判断标准只有一条:这段代码跑的时候,页面还能不能响应?不能,就切。切的时候注意:setTimeout 0 毫秒是排到任务队尾,queueMicrotask 是插队到微任务队列——想让页面喘气、让渲染有机会跑,要用任务,不要用微任务。微任务插队插得再多,渲染还是等不到。
第十步:queueMicrotask 的两个正经用途
微任务不是不能用,是只用在它该用的地方。MDN 给了两个正经用途。第一个是保证顺序一致:有缓存就直接同步触发 load 事件,没缓存就走 fetch 的 Promise,两个分支的顺序不一样——没缓存的时候,先打“正在取数据”,再打“数据取到了”,最后打“数据已加载”;有缓存的时候,“数据已加载”会抢在“数据取到了”前面。修法是在有缓存的分支里也用 queueMicrotask 包一下,让设置数据和触发事件都发生在微任务里,两个分支的顺序就一致了。核心是:不管数据是同步拿到的还是异步拿到的,对外表现出来的顺序要一样,别让调用方猜。
第二个是批量操作:sendMessage 每次被调,先把消息推进数组;如果是第一条,就排一个微任务,微任务跑的时候把整个数组一次发出去。因为微任务要等当前任务退出才跑,所以同一轮里多次调用 sendMessage,消息都会进同一个数组、同一发 fetch。等微任务跑的时候,数组里可能已经攒了好多条消息,一次发完,省掉了多次调用的开销。这里的关键是那个长度判断:只有数组长度是 1 的时候才排微任务,后面的调用只管往数组里加,不再排新的。两个用途的共同点是:都在利用“微任务在当前任务退出、别的回调跑之前执行”这个时机,而不是拿它当“更快”的定时器。
第十一步:10 的阶乘,微任务等主程序退场才跑
微任务指南里还有一个例子,值得亲手跑一遍:doWork 函数里先排一个 queueMicrotask,再算 10 的阶乘。算的过程是 result 从 1 开始,i 从 2 乘到 10:1 乘 2 是 2,乘 3 是 6,乘 4 是 24,乘 5 是 120,乘 6 是 720,乘 7 是 5040,乘 8 是 40320,乘 9 是 362880,乘 10 是 3628800。所以 10 的阶乘等于 3628800。主程序先打“主程序开始”,再 setTimeout 0 毫秒排一个普通回调,再打“10 的阶乘等于 3628800”,最后打“主程序退出”。微任务里的紧急回调,要等整个主程序退出、任务退出、栈空了才跑,绝不是 doWork 一退场就跑。
这句话值得单独记下来:微任务不是在函数退出的时候处理,是在主程序退出的时候处理。函数退场和任务退场是两回事:函数退场只是栈里少了一个帧,任务退场才是栈空了。doWork 算阶乘的时候,栈里还有主程序的帧,微任务只能等着。很多时序 bug 的根子就在这里:以为“我调了 queueMicrotask,下一行就该跑了”,其实它要等到整个任务跑完。想验证的话,在控制台把这个例子跑一遍,看“主程序退出”是不是总在“紧急回调”前面。
第十二步:120 次时序事故,先对着图自查

上图是虚构的灯塔书店项目一个季度的统计:和事件循环时序相关的事故一共 120 次。长任务占着线程、页面几秒点不动 42 次,占 35.0%,是最多的;微任务递归加微任务、渲染永远等不到 28 次,占 23.3%;以为 setTimeout 0 毫秒就是立刻跑、结果顺序全错 24 次,占 20.0%;两个 then 回调的顺序猜错、以为会交错执行 14 次,占 11.7%;缓存分支和网络分支顺序不一致、调用方拿到的数据时有时无 12 次,占 10.0%。42 加 28 加 24 加 14 加 12 等于 120,账是平的。这些数字是编出来的例子,目的是让你一眼看到:前两类加起来快六成,而它们都是同一个根源的不同写法——不知道“谁先跑、谁后跑、谁会插队”。
自查清单:写完异步代码,逐条打勾
第一,正在跑的函数不会被打断,一口气跑完才换下一个。第二,一轮循环是三步:一个任务,清空微任务,可能渲染。第三,微任务先于任务跑,setTimeout 0 毫秒是排到任务队尾,不是立刻跑。第四,微任务会插队,递归加微任务会饿死渲染和后面的任务。第五,任务跑得太久页面就卡住,长任务要切小、排到下一个任务。第六,想让页面喘气、让渲染有机会跑,用任务,不要用微任务。第七,不管数据是同步拿到的还是异步拿到的,对外表现的顺序要一致,必要的时候用 queueMicrotask 把同步分支也包成微任务。第八,微任务在整个任务退出、栈空了才跑,不是在函数退场的时候跑。第九,Promise 的 then 回调是微任务,执行器本身是同步跑的。九条里任何一条答不上来,回到对应的章节再读一遍,比多背十个 API 都有用。
评论 (0)
原始来源
相关文章
函数你每天都在调,这篇把你一直在做的事讲清楚。本文按 MDN 的《Functions》《Arrow function expressions》《Rest parameters》三篇官方文档讲清楚:声明与表达式、参数与实参、默认值、剩余参数、展开语法、返回值、箭头函数省写规则、this 的坑、回调与高阶函数、作用域。
同一个页面要在手机、平板、电脑上都站得住。本文按 MDN 的《Responsive web design》《Using media queries》《viewport meta 参考》三篇官方文档讲清楚:流式 HTML、viewport 标签、流式网格与 max-width、图片不撑破容器、媒体查询语法、按内容定断点、mobile-first、响应式字号、按能力查设备与上线检查清单。
JavaScript 里数字只有一种类型 Number,存成 64 位浮点数,所以 0.1 + 0.2 等于 0.30000000000000004。本文按 MDN 的《Basic math in JavaScript》《Math》《Number》三篇官方文档讲清楚:一种数字类型、浮点误差、钱改成分算、字符串转数字、NaN 与 Infinity、安全整数、四种取整、Math.random、Math 工具箱与显示格式化。