Web Worker 与主线程分片:300 万次质数统计的阻塞实测与选型
一、把 962 毫秒的计算放进主线程,页面就死了
前端性能优化里被讨论最多的是"如何让代码跑得更快",但真正决定用户体验的往往是另一件事:代码运行期间,主线程还有没有能力响应输入。一段耗时 900ms 的纯计算,即使它已经是最优实现,只要它同步跑在主线程上,用户在这 900ms 内点击按钮、滚动页面、切换输入框都不会有任何反馈——浏览器不会把这些事件派发给一个繁忙的主线程,它们会排队,等计算结束后一次性倾倒出来。
这篇文章不做概念科普,而是用一次可控的对照实验把三种方案摆在一起比较:主线程直接算完、丢给 Web Worker、在主线程分片让出。实验只回答两个问题:主线程被阻塞多久,以及为了不阻塞要付出多少额外时间。
二、实验设计
被测任务刻意选成一个无法被 JIT 优化掉的 CPU 密集型负载:统计 300 万以内的质数个数,循环内部混入一个线性同余伪随机数推进,避免迭代被整体消除。三个版本的算法、数据量、初始种子完全一致,只在"在哪跑、怎么切片"上有差别。
观测手段有两套,互相印证:
- PerformanceObserver 的 longtask 条目:浏览器原生上报超过 50ms 的长任务及其持续时长,这是阻塞的客观证据。
- 10ms 心跳定时器:每 10ms 打一个点,记录相邻两次打点的实际间隔。主线程空闲时间隔稳定在 9~12ms,一旦被占用,间隔会直接跳到阻塞时长。心跳的最大间隔基本等于用户可感知的卡顿时长。
运行环境:Chrome 152,Windows,6 个逻辑核心,页面为普通的同源业务页,未开启任何实验性开关。
三、方案 A:主线程直接算完
const N = 3_000_000;
const t0 = performance.now();
let s = 123456789, primes = 0;
for (let i = 2; i < N; i++) {
s = (s * 1103515245 + 12345) & 0x7fffffff;
let isP = true;
for (let d = 2; d * d <= i; d++) { if (i % d === 0) { isP = false; break; } }
if (isP) primes++;
}
console.log(performance.now() - t0, primes);
结果没有任何意外:总耗时 962ms,longtask 上报了一条时长 962ms 的记录,心跳最大间隔 960ms。也就是说这近一秒的时间里,主线程完全失去响应能力。这类代码通常在"点击导出""批量校验""本地解析大文件"的场景里出现,开发阶段用几百条测试数据跑得飞快,一上生产数据量翻十倍就变成白屏卡死。
四、方案 B:交给 Web Worker
Worker 的关键约束是不能访问 DOM,只能通过消息通信交换数据。所以计算逻辑必须自包含,或者抽成可被 Worker importScripts / type:module 加载的独立模块。这里用 Blob URL 内联,方便演示也方便按需创建:
const workSrc = `
self.onmessage = function (e) {
const N = e.data;
let s = 123456789, primes = 0;
for (let i = 2; i < N; i++) {
s = (s * 1103515245 + 12345) & 0x7fffffff;
let isP = true;
for (let d = 2; d * d <= i; d++) { if (i % d === 0) { isP = false; break; } }
if (isP) primes++;
}
self.postMessage({ primes, s });
};`;
const url = URL.createObjectURL(new Blob([workSrc], { type: 'text/javascript' }));
const w = new Worker(url);
const t0 = performance.now();
const result = await new Promise((resolve) => {
w.onmessage = (e) => resolve({ ...e.data, ms: performance.now() - t0 });
w.postMessage(N);
});
w.terminate();
URL.revokeObjectURL(url);
测量结果:总耗时 999ms,主线程 longtask 记录为 0 条,心跳间隔全程保持在 9~12ms。
两个数字都值得注意。第一个是代价:999ms 对比 962ms,多出约 3.8%。这部分开销来自 Worker 启动(线程创建 + 脚本编译)、消息序列化与反序列化。本次传输的只是一个整数和一个对象,所以开销很低;如果回传的是几十兆的 ArrayBuffer,结构化克隆的成本会线性上升,甚至反超计算本身的耗时。这正是 Transferable 的用武之地:
// 转移所有权,零拷贝,代价是原 buffer 在发送方变为不可用
worker.postMessage(buffer, [buffer]);
第二个数字是收益:主线程的 longtask 归零。计算总量没变,但用户可感知的卡顿消失了。这是 Worker 的核心价值——它不加速计算,它只是把计算搬离了渲染与交互所依赖的那条线程。
五、方案 C:主线程分片让出
有些项目不能或不愿引入 Worker(构建链路限制、需要访问 DOM、需要复用大量闭包上下文),此时常见的替代方案是把大循环切成小批,每批结束后让出事件循环:
const CHUNK = 20000;
const isPrime = (i) => {
for (let d = 2; d * d <= i; d++) if (i % d === 0) return false;
return true;
};
let primes = 0;
for (let start = 2; start < N; start += CHUNK) {
const end = Math.min(start + CHUNK, N);
for (let i = start; i < end; i++) if (isPrime(i)) primes++;
await new Promise((r) => setTimeout(r, 0)); // 关键:让出
}
结果呈现出完全不同的取舍:总耗时 1769ms,longtask 为零,心跳最大间隔 25ms,超过 30ms 的间隔一次都没有。
用户可感知的卡顿确实消失了,但总时长比 Worker 方案多出约 77%,比直接算多出约 84%。原因很直白:每次 setTimeout(0) 让出后,浏览器至少要处理一次任务调度和渲染机会,实际等待通常在 1~4ms 量级;150 次切分累积起来就是数百毫秒。此外分片并不能真正并行——六个核心里有五个闲置,只有主线程在分时复用。
还要注意 setTimeout 的嵌套层级问题:连续嵌套超过 5 层后会被强制钳制到 4ms 起步。因此分片更适合用 MessageChannel 或 scheduler.postTask 这类不受钳制的调度方式,或者干脆把切片做大一点,把切分次数控制在几十次以内。
六、三组数据放在一起
方案 总耗时 主线程最长阻塞 长任务条数
主线程直接计算 962ms 962ms 1
Web Worker 999ms 0ms 0
主线程分片(20k) 1769ms 0ms 0
结论可以压成三句话:
- 只要任务是纯计算且数据可序列化,Worker 是唯一同时满足"不阻塞"和"不牺牲总时长"的方案,本次代价仅 3.8%。
- 分片是兜底手段,不是优化手段。它用总时长换响应性,本次多付了 77%,任务越碎付得越多。
- 心跳间隔比总耗时更接近用户感受。962ms 与 999ms 对用户几乎无差别,但 962ms 的阻塞和 0ms 的阻塞是两种产品。
七、落地时的四个坑
坑一:Worker 里的错误不会冒泡到 window。需要显式挂 worker.onerror 与 self.onunhandledrejection,否则计算失败时页面只会静默地永远等下去。生产环境还应在 Worker 内部加超时兜底,超时后 terminate() 并走降级路径。
坑二:频繁创建销毁 Worker 的成本不可忽略。单次创建在本次环境里约 15~30ms,短任务场景下这个开销可能超过计算本身。正确做法是维护一个 Worker 池,按任务数复用实例,用自增 id 做请求与响应的配对:
let seq = 0;
const pending = new Map();
worker.onmessage = (e) => {
const cb = pending.get(e.data.id);
if (cb) { pending.delete(e.data.id); cb(e.data.payload); }
};
function call(payload) {
const id = ++seq;
return new Promise((resolve) => {
pending.set(id, resolve);
worker.postMessage({ id, payload });
});
}
坑三:SharedArrayBuffer 不是随手可用的。它要求页面处于跨源隔离状态,即响应头同时带 Cross-Origin-Opener-Policy: same-origin 与 Cross-Origin-Embedder-Policy: require-corp。开启后所有跨源子资源都必须带 CORP 或 CORS 头,图片、字体、第三方脚本常常因此集体加载失败。若只是为了避开一次克隆,付出的改造成本通常并不划算。
坑四:不要用分片去掩盖本不该在主线程做的事。分片会让一段糟糕的架构变得"看起来不卡",从而失去被重构的动力。判据很简单:如果这段逻辑不需要 DOM、不依赖实时交互状态、输入输出都能序列化,它就应该在 Worker 里,而不是被切成一百段塞回主线程。
八、选型建议
把决策收敛成一条判断链:任务是否超过 50ms?没有就留在主线程,不要为了"架构纯粹"引入 Worker。超过 50ms,看它是否需要 DOM 与页面上下文:需要,走分片并接受总时长上升;不需要,走 Worker。数据量超过几兆的二进制,用 Transferable 转移所有权而不是克隆;任务高频且短小,用 Worker 池而不是每次 new。
最后回到那三个数字:962ms、999ms、1769ms。真正该被优化的从来不是这三个数字里最小的那个,而是让主线程任意时刻的阻塞都趋近于零。用户不会感谢你把 962ms 优化到 900ms,但一定会感知到点击之后页面有没有反应。
- 点赞
- 收藏
- 关注作者
评论(0)