一个接口需要算一份报表,逻辑是一个 5000 万次的循环。单个请求跑完大约 400 毫秒,本地测试没问题。上线后只要同时来几个请求,所有接口一起变慢,连健康检查都超时。

原因是那 400 毫秒里,JavaScript 主线程一直被这个循环占着,事件循环转不动,别的请求的回调、定时器、I/O 完成通知全排在后面。不是 CPU 不够,是「一个线程被独占」。我把同样的循环放到 worker_threads 的线程里跑,主线程在这 400 毫秒内照常处理定时器,实测计时器触发了 27 次;直接在主线程跑,触发 0 次。

这篇讲 worker_threads:它和 child_process 的区别、消息怎么传、共享内存怎么用、线程崩了怎么办。线程和进程在操作系统层面的区别可以回看线程与调度,这里只讲 Node 的接口和实际边界。所有数据来自本机实跑,Node v24.21.0,Windows x64。

worker_threads 是什么:同进程里的第二个 JS 线程

worker_threads 允许在同一个进程里开多个 JavaScript 执行线程。每个 worker 有自己的 V8 实例、自己的事件循环、自己的堆,主线程和 worker 之间可以传消息,也可以共享一块内存。它比开进程轻:不用重新启动整个 Node,创建开销小,内存也可以部分共享。

入口判断用 isMainThread:主线程里它是 true,worker 里是 false。worker 通过 parentPort 和主线程通信,启动参数放在 workerData 里。threadId 是线程编号,主线程是 0,我实测两个 worker 分别是 1 和 2。

const { Worker, isMainThread, parentPort, workerData, threadId } = require('node:worker_threads');

if (isMainThread) {
  const w = new Worker(__filename, { workerData: { n: 5 } });
  w.on('message', (m) => console.log('main got', m));
} else {
  parentPort.postMessage({ doubled: workerData.n * 2, threadId });
}
主线程处理请求、事件循环、调度 worker,不能长时间阻塞。
Worker 线程独立事件循环和堆,适合 CPU 密集计算、解析、压缩。
消息通道postMessage 传数据,结构化克隆,异步到达。
共享内存SharedArrayBuffer 加 Atomics,多线程读写同一块字节。

不要把它和 libuv 的线程池混淆。libuv 的线程池是 Node 内部用来做文件、DNS、加密这些阻塞操作的,你没法往里塞自己的 JS 函数。worker_threads 是给业务代码用的「第二个 JS 执行环境」,两者不是一回事。

创建 worker 有两种写法。CJS 里可以传当前文件路径 __filename;ESM 里用 new Worker(new URL('./worker.mjs', import.meta.url)),因为 ESM 没有 __filename。也可以传一段代码字符串加 { eval: true },适合临时实验,不适合生产:没有文件路径,堆栈和调试都很难看。

workerData 只在启动时克隆一次,之后主线程再改变量,worker 里看不到。它不是「共享对象」,而是「启动参数的一份副本」。需要运行中更新,只能靠消息或共享内存。

worker 数量也不需要等于核数。每个 worker 有自己的 V8 堆,常驻内存是主线程的好几倍。CPU 密集任务一般开到核数减一,留一个核给主线程和系统;内存紧张时还要再减。

消息传递:结构化克隆不是 JSON

主线程用 worker.postMessage(value) 发,worker 用 parentPort.postMessage(value) 发,接收方监听 message 事件。消息是异步的,发出后不会立刻到达;同一个发送方发出的消息按顺序到达。

传输用的算法叫结构化克隆(structured clone),比 child_process 的 JSON 序列化强:Date 还是 Date,Map 还是 Map,Set、RegExp、Error、ArrayBuffer 都能保留类型。但函数、类实例的方法、DOM 节点仍然不能传。我实测传一个箭头函数,postMessage 直接抛出:

DataCloneError: () => 1 could not be cloned.

这个错误是同步抛出的,不在 error 事件里,所以要用 try/catch 包住 postMessage。很多人以为「发送失败会走 error 事件」,结果异常直接把当前逻辑打断。

消息大小也有成本。结构化克隆要遍历对象、复制内容,大对象每次传递都占 CPU 和内存。传 10 MB 的对象,主线程和 worker 各有一份,瞬间多 20 MB。频繁传大对象时,要么改成传「一次一批」,要么用共享内存避免复制。

消息里不要放 Promise、函数、带循环引用的对象。需要传「动作」时,传一个字符串或数字标识,让接收方自己查表决定执行什么。把逻辑写进消息里,既传不过去,也不安全。

两个线程之间也可以不开新线程直接建通道:MessageChannel 返回一对 port1 和 port2,把其中一个通过 postMessage 转移给 worker,两边就能在这个端口上双向通信。适合一个 worker 要同时和主线程、另一个 worker 对话的场景,比所有消息都挤在 parentPort 上清晰。

消息通道没有内建的「按容量阻塞」。主线程发得比 worker 处理得快,消息会排在内置队列里,内存上涨。要控制节奏,可以每批消息带一个序号,worker 处理完回一个 ack,主线程收到 ack 再发下一批。这和多进程 IPC 的背压处理是同一个思路。

worker 里也能用 require 和 import,但模块加载是每个线程独立做的。同一个模块在主线程和 worker 里各有一份实例,模块级变量不共享。别指望在模块顶层改一个变量,worker 就能看到;这正是「每个 worker 有自己的堆」的直接后果。

共享内存:SharedArrayBuffer 与 Atomics

如果数据量大、又要频繁读写,复制就不划算了。这时用 SharedArrayBuffer:一块可以被多个线程同时访问的内存。创建后在 workerData 里传给 worker,两边拿到的是同一块字节,不是副本。

const shared = new SharedArrayBuffer(4);
const arr = new Int32Array(shared);
// 主线程和 worker 都持有 arr,读写同一块内存
Atomics.add(arr, 0, 1);
console.log(Atomics.load(arr, 0)); // 1

我实测 worker 里 Atomics.add(arr, 0, 1),主线程 Atomics.load(arr, 0) 读到 1。共享内存没有复制,改的是同一块字节。这就是它和 postMessage 的本质区别。

共享带来竞态。两个线程同时做「读、加一、写回」,可能都读到旧值,最后只加了一次。所以共享内存的读写要用 Atomics 提供的原子操作:Atomics.add、Atomics.sub、Atomics.load、Atomics.store、Atomics.compareExchange。普通下标读写不是原子的,不能用来做计数器。

Atomics.wait 会让当前线程睡眠,直到另一个线程 Atomics.notify。它适合做「等待某个标志位」的同步,但不要在主线程调用:主线程睡了,事件循环就停了,整个进程像卡死一样。我实测在主线程等待会让定时器延迟,症状和死循环很像,但 CPU 反而不高。

共享内存的读写规则
分配new SharedArrayBuffer(bytes)
视图Int32Array / Float64Array
原子读写Atomics.load / store / add
等待通知Atomics.wait / notify

Atomics.compareExchange 是「比较并交换」:只有当前值等于期望值时才写入新值,返回旧值。它适合实现锁和「只初始化一次」的逻辑。比如两个线程都想初始化配置,先 compareExchange(flag, 0, 1),返回 0 的那个负责初始化,返回 1 的跳过。

Atomics 保证的是单个操作的原子性,不保证多个操作组合起来也原子。先 load 再 store,中间仍可能被别的线程插进来。需要「一串操作不可分割」时,要用锁,而锁本身又要用 compareExchange 实现。这就是为什么共享内存编程容易出错。

SharedArrayBuffer 本身只是字节,要配合类型化数组才有意义。new Int32Array(shared) 把每个元素按 4 字节解释,new Float64Array(shared) 按 8 字节。同一个共享块可以被不同视图读写,但索引含义要自己约定。混用视图时最容易出现「读到的数和写进去的不一样」。

转移所有权:不复制,直接把 Buffer 交出去

传大块 ArrayBuffer 时,还有一个比复制更快的办法:转移所有权。把 ArrayBuffer 放进 postMessage 的第二个参数 transferList,内存直接交给接收方,发送方手里那份变成「已分离」,长度变成 0。

w.postMessage(buffer, [buffer]);
// 接收方 byteLength 16
// 发送方 byteLength 0

我实测转移一个 16 字节的 ArrayBuffer,worker 收到后长度是 16,主线程手里的同一个对象长度变成 0。这不是 bug,是设计:所有权已经转移,原来那份不能再读写。转移后再去访问,会得到空数据或抛错。

转移适合「一次性把数据交给对方处理、自己不再用」的场景,比如把读好的文件内容交给 worker 压缩,或者把计算结果交给主线程写盘。它避免了复制,但要求你清楚谁拥有这份数据;转移后还拿着旧引用继续用,就会出现「数据莫名变空」。

转移还有个前提:只有 ArrayBuffer 和 MessagePort 这类「可转移对象」能放进 transferList。普通对象、字符串、SharedArrayBuffer 都不能转移。SharedArrayBuffer 本来就是共享的,不需要转移,也不应该放进列表。

转移之后,发送方不要再持有那个引用。常见错误是转移完还把它塞进数组或缓存里,后面用到时发现长度是 0。正确做法是转移后立刻把变量置空,让「已转移」这件事在代码里可见。

线程的生命周期:退出、终止与崩溃

worker 正常执行完代码、事件循环空了,会自己退出,触发 exit 事件,参数是退出码。要提前结束,用 worker.terminate(),它返回 Promise,等线程真正结束后 resolve。terminate 是强制停止,worker 里的清理逻辑不一定有机会执行。

worker 里抛未捕获异常时,主线程收到 error 事件,然后收到 exit,退出码是 1。我实测一个直接 throw new Error('boom') 的 worker,打印顺序是 error event boom、exit 1。error 事件必须监听,否则未处理的 error 会让主线程也崩掉。

worker 默认会阻止进程退出:只要还有一个 worker 活着,主线程的事件循环即便空了,进程也不会结束。反过来,主线程退出时,所有 worker 都会被终止。要「后台线程不阻止退出」,可以对 worker 调 unref(),让它不参与进程存活判断。

线程池要自己管理。频繁创建 worker 开销不小,常见做法是启动时建固定数量的 worker,用一个队列分发任务,任务完成后 worker 继续等下一个。这就是「线程池」模式,worker_threads 本身没有内置池,需要自己写或借助库。

new Worker 还能传 resourceLimits,限制 worker 的堆大小,比如 { maxOldGenerationSizeMb: 64 }。超限时 worker 会报 ERR_WORKER_OUT_OF_MEMORY 并退出,而不是拖垮整个进程。给不可信或不可控的计算加这个限制,能把故障圈在单个线程里。

worker 对象有 ref() 和 unref()。默认 worker 是「被引用」的,会阻止进程退出;unref() 之后,主线程没事做时进程可以正常结束,worker 会被一起停掉。做「后台预热」这类不需要保证完成的任务时用 unref,做「必须算完」的任务时保持默认。

还有一个常被忽略的成本:启动 worker 要重新初始化 V8、加载模块、跑一遍入口代码。一个空 worker 的启动也在几十毫秒量级,和具体机器有关。按请求创建、用完销毁,在高并发下开销很明显;复用线程池才是常态。

worker 也不是「越多越好」。线程之间切换有开销,共享内存的竞争也会让 CPU 花在等锁上。先把任务拆成互不依赖的块,再按核数配线程,比一上来就开满更有效。

terminate() 之后不要立刻假设线程已经结束。它是异步的,返回 Promise 才代表真正停止。紧接着就用共享内存或再创建同名资源,可能和还没退出的线程冲突。等 Promise resolve 再做下一步,是更稳的写法。

消息还有一个容易忽略的点:同一对端口之间,消息按发送顺序到达;但多个 worker 交叉发消息时,没有全局顺序。日志里如果按时间戳对不上,先看是不是多个线程都在写同一个文件或同一个输出。每次写日志带上 threadId,比事后猜要省事。

线程池的任务队列本身也要有上限。任务堆积往往比线程数量更危险:内存里排着几十万个待处理消息,进程会先被内存压垮,而不是 CPU。队列满了要么拒绝,要么让上游等待,别让它无限增长。

现象对照

现象真实原因第一步查什么
所有请求一起变慢,CPU 很高主线程被同步计算占住,事件循环停了用 hrtime 量同步段耗时,搬进 worker
DataCloneError消息里有函数、类实例或不可克隆对象打印消息结构,改成纯数据
传过去的值类型变了误以为走 JSON 序列化确认用的是结构化克隆,Date/Map 会保留
共享计数器偶尔少加普通下标读写不是原子操作改用 Atomics.add
主线程像卡死,CPU 不高主线程调了 Atomics.wait把等待移到 worker,主线程只 notify
转移后原 Buffer 长度变 0transferList 转移了所有权转移后不要再使用原对象
worker 崩了主线程也崩没监听 error 事件加 worker.on('error')
进程一直不退出还有 worker 活着结束后 terminate() 或 unref()
频繁创建 worker 后延迟高没有复用线程,创建开销累积改成固定大小的线程池
传大对象后内存翻倍结构化克隆复制了一份改用共享内存或 transferList
worker 数量加多后内存吃紧每个 worker 有独立 V8 堆按核数和内存限制数量,复用线程池
消息发太快,内存一直涨通道没有容量上限,消息排队加 ack 或分批,控制发送节奏

边界与代价

第一个代价是「不能随便共享」。进程之间完全隔离,线程之间共享又意味着竞态和锁。Node 把共享限制在 SharedArrayBuffer 和 Atomics 上,普通对象仍要复制。这个设计减少了踩坑,但也意味着「共享一个复杂对象」做不到,只能共享字节。

第二个代价是「崩溃会连带」。worker 是同一进程里的线程,一个线程把进程搞崩(比如原生代码段错误),整个进程都会退出,不像多进程那样能隔离。worker 里的普通 JS 异常可以通过 error 事件接住,但原生崩溃接不住。

第三个代价是「调试和观测」。线程之间共享进程 id,日志里分不清谁是谁,要带 threadId。断点、性能分析也要指定线程。CPU 曲线看起来是一个进程,实际可能是多个线程在抢。

第四个代价是「选型」。I/O 密集的任务不需要 worker,异步 I/O 本来就是并发的;只有 CPU 密集、并且能拆成独立块的任务才值得开线程。为了「用上多线程」而把简单逻辑搬进 worker,只会增加消息传递和生命周期管理的复杂度。

还有一个现实限制:SharedArrayBuffer 的可用性和安全策略有关。在浏览器里需要跨源隔离头,在 Node 里默认可用,但跨进程传递仍然要序列化。不要以为「共享内存」能跨进程用,它只在同一进程的线程之间有效。

进程和线程的选择可以用一张简单的判断表:任务需要强隔离、可能崩溃、要独立部署,用进程;任务只是 CPU 密集、需要频繁共享数据、希望低开销,用线程。两者都能做「并行」,但失败模式和运维方式完全不同。

判断要不要 worker,只看一个问题:这段代码执行时,主线程是不是完全不能做别的事。如果是纯计算、且耗时超过几十毫秒,就值得考虑;如果主要是等 I/O,异步已经能并发,开线程只会增加复杂度。

如果任务之间需要频繁同步,比如一边算一边等另一个线程的结果,线程不一定比进程快。同步本身有开销,锁和等待还可能让线程空转。能拆成互不依赖的块,才是最理想的并行;拆不开时,先考虑算法优化,而不是加线程。

小结

worker_threads 在同一个进程里开多个 JS 线程,各有独立事件循环和堆;主线程用 isMainThread 判断,worker 用 parentPort 通信;消息走结构化克隆,函数传不了,DataCloneError 是同步抛出;SharedArrayBuffer 加 Atomics 才能安全共享,普通下标读写有竞态;transferList 转移所有权后原对象失效;worker 的 error、exit、terminate 都要处理,否则要么崩主线程,要么进程不退出。

当天可以自己验证的练习:

  1. 写一个 5000 万次循环,先在主线程跑并用 setInterval 数触发次数,再放进 worker 对比。
  2. 用 postMessage 发一个箭头函数,打印抛出的错误名和消息。
  3. 用 SharedArrayBuffer 加 Atomics.add 做计数器,两个 worker 各加 1000 次,检查最终值。
  4. 把一个 ArrayBuffer 放进 transferList,打印转移前后两边的 byteLength。
  5. 让 worker 抛异常,观察主线程收到的 error 和 exit 参数。

下一篇讲异步与事件循环:各阶段、Promise 与取消。前面反复出现「事件循环被堵住」「微任务比定时器先跑」这些说法,下一篇把它们拆开:定时器、I/O 回调、setImmediate、微任务分别在什么时候执行,为什么 process.nextTick 会饿死 I/O。系统层面的 I/O 模型可以回看I/O 模型。