别让主线程一个人扛:Web Workers,把重活交给另一条线程
主线程又要画页面又要算账,一算就卡。Worker 是另一条线程、另一个全局上下文,两边只靠消息传话。本文按 MDN 的《Using Web Workers》与《Worker》两篇官方文档讲清楚:new Worker、postMessage 与 onmessage、结构化克隆的复制语义、Worker 里能与不能、onerror 与 terminate()、SharedWorker、Transferable 零拷贝,另附虚构咖啡馆点单页一个月 100 次 Worker 翻车的分布。

先把这篇的边界说清楚。站里已经有不少 JavaScript 基础指南:事件循环指南讲过单线程里任务怎么排队,Promise 与 async 讲过怎么等一个异步结果,生成器指南讲过一次只给一个值、要的时候再算。这篇不讲它们,只讲一件事:主线程忙不过来的时候,怎么把重活交给另一条线程去算,也就是 Web Workers。下面用到的“青石咖啡馆”还是那个虚构的练手项目:一个帮街边咖啡馆做点单的网页小工具。之前几篇讲的是它的点单页怎么做决定、怎么循环、怎么取数、怎么约时间,这回讲的是它的月底对账:店主要算一张两千行的对账单,还要算一堆优惠组合,主线程一算就卡,按钮点不动、页面定在那里。本文所有以它为例的操作、代码和数字,都是为了讲清楚做法编出来的,不是真实记录。所有关于 Worker 的语法与行为,都来自 MDN 的《Using Web Workers》与《Worker》两篇官方文档,来源见每篇的 meta 信息与 evidence 记录。读完这篇,你应该能做到四件事:会建一个 Worker、会用 postMessage 和 onmessage 两边传话、知道 Worker 里能干什么、不能干什么、知道什么时候该用 Worker、什么时候别用。事件循环指南讲的是“一个线程里怎么排队”,这篇讲的是“再开一条线程”,两件事合起来,才是浏览器里并发的完整样子。
第一步:先看问题,主线程又要画页面又要算账
青石咖啡馆的点单页平时跑得挺顺,直到店主点开“月底对账”:两千行订单要一行一行对,还要算满减、第二杯半价、会员折扣这几种优惠怎么组合最划算。主线程只有一条,又要画页面、又要接按钮、又要跑这段算账的代码,算账一跑起来,页面就定住了,按钮点了没反应,取餐号也不刷新了,等算完了才一下子全跳出来。问题不在代码写错了,而在活太重:同一条线程上,算账和画页面抢的是同一份时间。Worker 的办法是换一条线程:把算账的活连人带代码搬到另一条线程上去算,主线程只负责两件事,收到结果、把结果画出来。MDN 的原话是:Worker 主要用来让代码在不阻塞用户界面线程的情况下做处理器密集型计算,例子就是用一个 Worker 来算斐波那契数。这一节先记住这个分工:主线程管页面,Worker 管重活,两边只靠消息传话。
第二步:Worker 是什么,另一条线程,另一个全局上下文
MDN 对 Worker 的定义只有一句话:Worker 接口代表一个可以由脚本创建的后台任务,它能给创建者发回消息。创建一个 Worker 很简单,调一下构造器、给一个脚本的地址就行:const myWorker = new Worker("worker.js")。但这行代码背后有三件事要先弄明白。第一,Worker 跑在另一个全局上下文里,这个上下文叫 DedicatedWorkerGlobalScope,和当前页面的 window 是两个地方。MDN 的原话是:Worker 运行在另一个不同于当前 window 的全局上下文中,所以在 Worker 里用 window 这个快捷方式去取当前全局作用域会报错,要用 self。第二,专用 Worker 只属于创建它的那个脚本,MDN 的原话是:专用 Worker 只能被最先创建它的脚本访问;共享 Worker 可以被多个脚本访问,第九步再讲它。第三,Worker 里面还能再建 Worker,只要子 Worker 和父页面同源就行,子 Worker 的地址是相对父 Worker 的位置来算的,不是相对页面的。我的判断是:把 Worker 想成“店里新招的一个帮手”,他有自己的桌子、自己的工具,主线程是前台,帮手在后厨算账,前台和后厨之间只靠传纸条说话,谁也别伸手去动对方桌上的东西。
第三步:建一个 Worker,先问浏览器支不支持
建 Worker 之前,先问一句浏览器支不支持,MDN 推荐的写法是把访问 Worker 的代码包起来:
if (window.Worker) {
// …
}
支持就继续,不支持就走老路子,别让页面直接报错。MDN 的基本例子是算两个数相乘:主线程里两个输入框,值一变就发消息给 Worker,Worker 乘完把结果发回来,页面再显示出来。创建 Worker 的写法有两种。第一种是直接给相对页面的地址:const myWorker = new Worker("worker.js")。第二种是打包器推荐的写法:const myWorker = new Worker(new URL("worker.js", import.meta.url)),这样路径是相对当前脚本来算的,不是相对当前 HTML 页面,打包器才能放心地改名、做优化。MDN 的原话是:这样一来路径是相对于当前脚本而不是当前 HTML 页面,打包器就可以安全地做重命名之类的优化,否则 worker.js 的地址可能指向一个不受打包器控制的文件,它就没法做任何假设。咖啡馆的例子:对账的 Worker 叫 reconcile.js,主线程建它、发过去两千行订单,剩下的事都在后厨做。还有一个细节:Worker 的构造器也接受 Blob 地址,也就是说可以把代码拼成一个 Blob、生成一个对象地址再传进去,MDN 在讲“嵌入式 Worker”时就是这么做的,第十步会再提到。
第四步:postMessage 与 onmessage,两边只靠消息传话
Worker 的全部魔法都在 postMessage 和 onmessage 这两个东西上。主线程想给 Worker 发消息,就调 Worker 对象的 postMessage;Worker 想给主线程发消息,也调 postMessage;两边收到消息,都靠 onmessage 这个事件处理器,消息本身在 message 事件的 data 属性里。MDN 的乘法例子是这样的,主线程:
[first, second].forEach((input) => {
input.onchange = () => {
myWorker.postMessage([first.value, second.value]);
console.log("Message posted to worker");
};
});
Worker 里:
onmessage = (e) => {
console.log("Message received from main script");
const workerResult = `Result: ${e.data[0] * e.data[1]}`;
console.log("Posting message back to main script");
postMessage(workerResult);
};
主线程再收回来:
myWorker.onmessage = (e) => {
result.textContent = e.data;
console.log("Message received from worker");
};
两个输入框的值一变,主线程就把两个值装进数组发过去,Worker 乘完把结果发回来,主线程把结果写进页面。MDN 特别提醒了一个不对称:onmessage 和 postMessage 在主线程里要挂在 Worker 对象上用,在 Worker 里面不用,因为在 Worker 里,Worker 自己就是全局作用域。我的判断是:把 postMessage 想成“传纸条”,onmessage 想成“收到纸条时要做的事”,纸条上写什么都行,数组、对象、数字都可以,但纸条只能单向一张一张传,不能两个人同时伸手去改同一张纸。
第五步:消息是复制过去的,不是共享的
主线程和 Worker 之间传的数据,是复制过去的,不是共享的。MDN 的原话是:在主页面和 Worker 之间传递的数据会被复制,而不是共享(除了某些可以显式共享的对象);对象在交给 Worker 时被序列化,到另一端再反序列化,页面和 Worker 没有共享同一个实例,结果就是两端各产生一个副本;大多数浏览器用结构化克隆来实现这一点。MDN 的例子是主线程发一个带日期的对象:
const myWorker = new Worker("my_task.js");
myWorker.onmessage = (event) => {
console.log(`Worker said : "${event.data}"`);
};
myWorker.postMessage({ lastUpdate: new Date() });
Worker 里:
self.onmessage = (event) => {
postMessage(`Last updated: ${event.data.lastUpdate.toDateString()}`);
};
发过去的是一个 Date 对象,到 Worker 里还是一个能调 toDateString() 的 Date 对象,不是变成字符串。MDN 还写了,结构化克隆算法能接受 JSON 和一些 JSON 接受不了的东西,比如循环引用。复制带来的直接后果是:主线程改了自己手里那份,Worker 手里那份不会跟着变,反过来也一样。我的判断是:把 postMessage 想成“复印一份寄过去”,原件还在你手里,复印件到了对方手里,两边各改各的,互不影响。咖啡馆的例子:主线程把两千行订单发给 Worker,Worker 在复印件上算优惠组合,主线程手里的订单列表一点没动,算完了 Worker 再把结果寄回来,主线程照着结果画页面。
第六步:Worker 里不能碰 DOM,但能发请求、能读写 IndexedDB
Worker 里不能做的事,第一条就是不能直接操作 DOM,也不能用 window 对象上的默认方法和属性。MDN 的原话是:你可以在 Worker 线程里跑任何你喜欢的代码,但有一些例外,比如不能直接操作 DOM,也不能用 window 对象的一些默认方法和属性。但能用的东西也不少,MDN 列出来的有:WebSocket、IndexedDB 这类数据存储机制,还能用 fetch() 或者 XMLHttpRequest 发网络请求,只不过 XMLHttpRequest 的 responseXML 属性永远是 null。MDN 在文章末尾又列了一张清单:Worker 里能用 Navigator、fetch()、Array、Date、Math、String、setTimeout() 和 setInterval() 这些标准功能。不能做的事,MDN 的原话是:你不能在 Worker 里直接影响父页面,包括操作 DOM 和使用那个页面的对象;你必须间接地做,先通过 postMessage() 把消息发回主脚本,再在事件处理器里做这些改动。咖啡馆的例子:对账 Worker 算完了不能直接改取餐屏上的数字,得把“第几行对不上、优惠组合是哪一种”发回主线程,主线程再去改页面。我的判断是:判断一个东西能不能在 Worker 里用,不用背清单,只问一句“它要不要碰页面”,要碰页面就发消息回主线程,不碰页面就大胆用。
第七步:出错了怎么办,onerror 与 terminate()
Worker 里跑着的代码也会出错,出错的时候主线程要能知道。办法是给 Worker 挂一个 onerror 处理器,MDN 的斐波那契例子就是这么写的:
worker.onerror = (error) => {
console.log(`Worker error: ${error.message}`);
throw error;
};
MDN 的原话是:当 Worker 里发生运行时错误时,它的 onerror 事件处理器会被调用,收到一个实现 ErrorEvent 接口的 error 事件;这个事件不会冒泡、是可以取消的,要阻止默认行为,Worker 可以调这个错误事件的 preventDefault() 方法。这个错误事件有三个值得关心的字段:message,是人类能读懂的错误信息;filename,是出错的脚本文件名;lineno,是出错的脚本行号。另一件事是结束 Worker:如果要立刻从主线程干掉一个正在跑的 Worker,就调它的 terminate() 方法,myWorker.terminate(),Worker 线程会被立刻杀掉。MDN 在 Worker 参考页里写得更直白:terminate() 会立刻终止 Worker,不会让 Worker 把手头的事做完,直接停在当下。我的判断是:terminate() 是“立刻停”,不是“等它收尾”,打烊时清掉对账 Worker 就用它;但如果 Worker 正在写 IndexedDB、正在发请求,立刻杀掉可能留下一半的东西,该等它回一条“写完了”的消息再杀,就先等消息,别图省事。
第八步:子 Worker 与 importScripts,Worker 里还能再分活
Worker 里还能再建 Worker,MDN 的原话是:Worker 线程里有个全局函数 importScripts(),可以用来导入脚本;它接受零个或多个地址参数,浏览器会加载每一个列出的脚本并执行它们。importScripts 的几条规矩值得记下来。第一,脚本按传入的顺序执行,下载可以乱序,但执行一定按顺序;第二,它是同步的,importScripts() 不返回,直到所有脚本都加载并执行完;第三,如果某个脚本加载失败,会抛出 NETWORK_ERROR,后面的代码不会再执行,但之前已经执行过的代码,包括用 setTimeout 推迟执行的代码,还是能用的;第四,importScripts() 后面的函数声明也会被保留,因为函数声明总是在其他代码之前被求值。子 Worker 的规矩是:子 Worker 必须和父页面同源,地址相对父 Worker 的位置来算,这样 Worker 才能管好自己的依赖。咖啡馆的例子:对账 Worker 里再分两个子 Worker,一个算满减、一个算会员折扣,算完了各自把结果发回对账 Worker,对账 Worker 再汇总发回主线程。我的判断是:新手先不用惦记子 Worker,一个 Worker 先跑顺了再说;真到“一个 Worker 自己也忙不过来”的时候,再按 MDN 的规矩拆,拆的时候记住“同源”和“地址相对父 Worker”这两条。
第九步:SharedWorker,一个 Worker 供多个页面用
专用 Worker 只属于创建它的脚本,共享 Worker 不一样:多个脚本,哪怕是不同的窗口、不同的 iframe、甚至不同的 Worker,都能用同一个共享 Worker。MDN 的原话是:共享 Worker 可以被多个脚本访问,哪怕这些脚本来自不同的窗口、iframe 甚至 Worker。建共享 Worker 的写法是 const myWorker = new SharedWorker("worker.js"),和专用 Worker 只差一个构造器名字。最大的区别在通信方式上:共享 Worker 要通过一个 port 对象来通信,这个端口要显式打开。MDN 的例子是两个页面共用一个 Worker,一个页面算乘法、一个页面算平方,Worker 里的写法是:
onconnect = (e) => {
const port = e.ports[0];
port.onmessage = (e) => {
const workerResult = `Result: ${e.data[0] * e.data[1]}`;
port.postMessage(workerResult);
};
};
有新连接进来时 onconnect 触发,从事件的 ports 属性里取出端口,再给这个端口挂 onmessage。主线程发消息要走端口:myWorker.port.postMessage([squareNumber.value, squareNumber.value]),收消息也一样:myWorker.port.onmessage = (e) => { result2.textContent = e.data; }。端口要在收发消息之前打开:如果用 onmessage 接消息,端口会被隐式打开;如果用 addEventListener 接消息,就得显式调 start() 方法,而且需要双向通信时,主线程和 Worker 里都要调。共享 Worker 什么时候关掉呢?MDN 的原话是:当不再被任何窗口、iframe 或 Worker 引用时,共享 Worker 就会被关掉;浏览器也可能在同源页面之间切换时把它留着,省得重启的成本;构造器还有个 extendedLifetime 选项,设成 true 可以让它在所有引用都关掉之后再多活一会儿,用来把状态写进存储、或者把统计数据发回服务器。我的判断是:共享 Worker 是“多人共用的后厨”,点单页和取餐屏两个页面共用一个算账 Worker 时再用它,一个页面自己用,专用 Worker 就够了,别为了用而用。
第十步:传大块数据,Transferable 零拷贝,传过去就清空
复制有个成本:数据越大,复印越慢。MDN 写了另一种办法:Transferable 对象,用零拷贝操作从一个上下文传到另一个上下文,传大数据集时性能提升很大。MDN 的例子是传一个 32MB 的数组:
// Create a 32MB "file" and fill it with consecutive values from 0 to 255 – 32MB = 1024 * 1024 * 32
const uInt8Array = new Uint8Array(1024 * 1024 * 32).map((v, i) => i);
worker.postMessage(uInt8Array.buffer, [uInt8Array.buffer]);
postMessage 的第二个参数就是转移列表,列进去的对象会被“搬过去”,不是“复印过去”。MDN 的原话是:当把一个 ArrayBuffer 从主应用传给 Worker 脚本时,原来的 ArrayBuffer 会被清空、不再能用,它的内容是实实在在地被转移到了 Worker 的上下文里。也就是说,转移之后主线程手里那个 buffer 就空了,再读它会报错,想再用就得让 Worker 再传回来。MDN 还提到了 SharedArrayBuffer:它让 Worker 和主线程同时操作同一段内存、不用走消息机制来交换数据,但用共享内存会带来显著的确定性、安全和性能方面的顾虑,MDN 在这里没有展开,只指了一篇讲 JavaScript 执行模型的文章。我的判断是:日常先用复制,数据真大到复制起来心疼了,再用转移;转移的时候记住“传过去就清空”,别在主线程里还留着对那个 buffer 的引用。咖啡馆的例子:两千行订单才几十 KB,复制过去就行;哪天要传一整年的对账单、几十 MB 的时候,再换转移。
第十一步:什么时候用 Worker,什么时候别用,一张检查清单
最后把选型说清楚。Worker 最适合三件事。第一,重计算:算斐波那契数、算优惠组合、算对账单,主线程算起来会卡住的活。第二,解析大文件、处理图片这种“数据大、算得久”的活。第三,需要长时间在后台跑、又不碰页面的活。MDN 的原话是:随着多核电脑越来越常见,把计算复杂的任务分给多个 Worker、让它们在多个处理器核心上跑,往往很有用。不适合用 Worker 的情况也要记住:活本来就很小,建 Worker 的成本、消息来回的成本比活本身还贵,别为了用 Worker 而用;要直接改 DOM 的活,Worker 干不了,还得发消息回主线程,多绕一圈。还有两个容易认错的“亲戚”:Service Worker 是坐在网页应用、浏览器和网络之间的代理,管的是离线体验、拦截网络请求、推送通知和后台同步,不是算账的;Audio Worklet 是直接处理音频的轻量 Worker,也不是算账的。调试 Worker 不用怕,MDN 的原话是:大多数浏览器能用和调试主线程完全一样的方式调试 Worker,Firefox 和 Chrome 都会把主线程和 Worker 线程的源文件列出来,都能下断点、打日志点;Chrome 用 chrome://inspect、Firefox 用 about:debugging 打开。检查清单照着过一遍:Worker 的脚本地址写对了没有,是不是同源;if (window.Worker) 问过了没有;消息是复制过去的,主线程改了自己那份、Worker 那份不会跟着变,记住了没有;Worker 里有没有直接碰 DOM、用了 window;出错了 onerror 挂了没有;用完了 terminate() 调了没有;SharedWorker 的端口打开了没有,start() 该调的调了没有。
上图是虚构的青石咖啡馆点单页一个月里 100 次 Worker 翻车的原因分布:直接在 Worker 里操作 DOM,以为和主线程一样 26 次;主线程改了传过去的对象,以为 Worker 里那份也会跟着变 18 次;发完消息立刻去读结果,忘了 Worker 是异步回消息的 15 次;Worker 的脚本地址写错或者跨域,文件 404 了却没挂 onerror 13 次;用完不 terminate,Worker 一直占着线程 11 次;把函数传给 postMessage,以为函数也能传过去 9 次;以为 Worker 和主线程共享同一份内存、同一个变量 8 次。26 + 18 + 15 + 13 + 11 + 9 + 8 = 100,账是平的。排前三位的错加起来占了快六成,都是“把 Worker 当成主线程的一部分”的误会:Worker 是另一条线程、另一个全局上下文,消息是复印过去的,结果是异步回来的。图里每一类都能在正文里找到对应的步骤:第一类见第六步,第二类见第五步,第三类见第四步,第四类见第三步和第七步,第五类见第七步,第六类见第五步,第七类见第五步和第十步。下次 Worker 行为不对,先按这个顺序查:先看 Worker 里有没有碰 DOM、用了 window,再看消息是不是复制过去的、结果是不是异步回来的,大概率两步就能定位到。
回头看这篇的四件事:new Worker("worker.js") 建一个后台任务,跑在 DedicatedWorkerGlobalScope 里,没有 window、要用 self;postMessage 发消息、onmessage 收消息,消息是复制过去的、不是共享的;Worker 里不能碰 DOM、能用 fetch、IndexedDB、setTimeout 这些,改页面要发消息回主线程;重计算、大文件、长时间后台活适合用 Worker,小活和直接改 DOM 的活别用。事件循环指南讲的是“一个线程里怎么排队”,这篇讲的是“再开一条线程”,两件事合起来,浏览器里的时间与并发才算讲全了。写完这篇就去把点单页的月底对账搬进 Worker:主线程只负责收结果、画页面,算账的活交给后厨,按钮就不会再卡住了。
评论 (0)
原始来源
相关文章
setTimeout 管一次,setInterval 管反复,但 delay 只保证“最少等这么久”:0 也不立刻、后台标签页还会更晚、超过 2147483647 会溢出。本文按 MDN 的 setTimeout 与 setInterval 两篇官方文档讲清楚:异步返回、传参、delay 的数字规矩、嵌套 4 毫秒、clearTimeout 与 clearInterval、递归 setTimeout、this 丢失与字符串参数,另附虚构咖啡馆点单页一个月 100 次定时器翻车的分布。
数组得一次全算好,生成器一次只给一个值,要的时候再算。本文按 MDN 的《Iterators and generators》《function*》《Generator》三篇官方文档讲清楚:next() 协议、function* 与 yield、for...of 消费、Symbol.iterator、yield* 委托、next(x) 往里传值、throw() 与 return(),以及什么时候该用生成器,另附虚构咖啡馆点单页一个月 100 次生成器翻车的分布。
数据里缺一层,整张点单页就可能白屏。本文按 MDN 的《Optional chaining》《Nullish coalescing》《Logical nullish assignment》三篇官方文档讲清楚:?. 三种写法与短路、可选调用与方括号取值、?? 与 || 在 0 和空字符串上的差别、?. 与 ?? 联手、?? 不能和 ||、&& 直接混写、??= 补默认值,另附虚构咖啡馆点单页一个月 100 次取不到值的分布。