一个服务按教程写好了 cluster,cluster.fork() 起了 4 个 worker,日志里 4 个 pid 都在打印,看起来一切正常。但压测时 CPU 只有一个核跑满,另外三个几乎空着,吞吐量和单进程差不多。
原因藏在 server.listen() 的参数里:写的是 listen(0, '127.0.0.1'),想让系统自动分配端口。结果每个 worker 各自绑定了一个不同的随机端口,请求全打到第一个启动的 worker 上,cluster 的端口共享根本没生效。
多进程是 Node 里最容易被「看起来能跑」骗过去的部分。进程起没起来、端口共没共享、消息发没发到、子进程崩了有没有人管,这些都不会在启动日志里明确告诉你。这篇按「怎么启动、怎么通信、怎么退出」三件事讲,系统层面的进程模型可以回看操作系统里的进程,这里只讲 Node 的接口和坑。
为什么单进程不够
Node 的 JavaScript 执行是单线程的。一个进程里,同一时刻只有一段 JS 在跑。文件读写、DNS 这些阻塞操作由 libuv 的线程池帮忙,但 CPU 密集的计算——大循环、复杂解析、图像处理——只能占着那一个线程,事件循环被堵住,所有请求一起等。
要利用多核,最直接的办法是开多个进程,每个进程一个事件循环,操作系统把不同进程调度到不同核心。进程之间内存独立,一个崩了不会直接带走别人,代价是不能像线程那样共享变量,通信要走 IPC(进程间通信,inter-process communication)。
多进程
内存独立,崩溃隔离好,通信要序列化,启动开销大。适合按 CPU 核扩展服务、跑独立的命令行任务。
多线程
内存可共享,启动开销小,但要处理锁和竞态。Node 里对应 worker_threads,下一篇讲。
我的本机是 Windows x64,下面所有进程实验都用 Node v24.21.0 实跑。Windows 没有 fork 系统调用,Node 的 fork 是「启动一个新的 node 进程再建立 IPC 通道」,和 Linux 的 fork 语义不同,这一点在跨平台排查时很重要。
我本机 os.cpus().length 是 12,内存 15.6 GB。一个 Node 服务要压满 CPU,理论上要接近 12 个 worker;但每个 worker 有独立内存,还要给操作系统和其他进程留余量,实际不会开到 12。进程数怎么定没有公式,先按核数的一半起步,压测看 CPU 和内存曲线再调。容器的 CPU 限额可能和 os.cpus() 不一致,别只看这个数字。
衡量「是不是 CPU 瓶颈」可以用 process.cpuUsage()。它返回用户态和内核态的微秒数,在一个时间段前后各取一次,差值接近墙钟时间的 100%,说明进程在满负荷算;远低于 100%,说明大部分时间在等 I/O。这个判断比看「CPU 使用率」更准,因为后者把等待也算进去了。
child_process 的四种启动方式
child_process 有四个常用函数,区别在「要不要 shell、输出怎么给、有没有 IPC」。选错了,问题会以「命令找不到」「输出被截断」「进程杀了不退」等形式出现。
| 方法 | 是否走 shell | 输出方式 | 典型用途 |
|---|---|---|---|
spawn | 否 | 流式,实时 | 长时间运行、输出很大的命令 |
exec | 是 | 缓冲到内存 | 短命令、需要管道和通配符 |
execFile | 否 | 缓冲到内存 | 执行已知可执行文件,参数可控 |
fork | 否 | 流 + IPC 通道 | 启动另一个 Node 模块并通信 |
exec 和 execFile 都会把子进程输出攒在内存里,等结束才回调。攒的上限是 maxBuffer,默认 1 MB。我让子进程输出约 1.2 MB,再调 exec,回调拿到的错误码是 ERR_CHILD_PROCESS_STDIO_MAXBUFFER,stdout 长度正好停在 1048576。命令本身没错,是缓冲区满了。
exec('node -e "..."', { maxBuffer: 1024 * 1024 }, (err, stdout) => {
console.log('err code', err && err.code); // ERR_CHILD_PROCESS_STDIO_MAXBUFFER
console.log('stdout len', stdout.length); // 1048576
});
输出可能很大时用 spawn,监听 stdout 的 data 事件边收边处理。spawn 不经过 shell,参数是一个数组,不存在空格拆分和引号转义的问题。要执行系统命令、用管道、用通配符时才需要 shell,这时用 exec,但不要把用户输入直接拼进命令字符串。
execFile 是「不经过 shell 的 exec」,参数同样是数组。它适合「程序固定、参数来自变量」的场景:既不用处理 shell 转义,又能拿到缓冲后的完整输出。我实测执行一个不存在的命令,错误码是 ENOENT,消息是 spawn definitely-not-a-command ENOENT。看到 ENOENT 先查命令是否在 PATH 里,不要先怀疑权限。
spawn 的 stdio 选项决定输出去哪。默认是 'pipe',父进程通过流读;设成 'inherit' 直接接到父进程的终端,适合命令行工具;设成 'ignore' 直接丢弃,适合不关心输出的后台任务。我实测 stdio: 'inherit' 时子进程的 console.log 直接出现在终端,父进程随后打印 exit 0。
exec 走 shell,意味着字符串里的 ;、|、&&、$() 都会被解释。把用户输入拼进去,就是命令注入。哪怕只是「文件名」,也可能包含空格和特殊字符。规则很简单:能用 execFile 或 spawn 就不用 exec;必须用 shell 时,参数要转义,或者改用参数数组。
同样执行一个不存在的命令,exec 和 execFile 的结果不同。exec 走 shell,Windows 的 cmd 返回退出码 1,stderr 是 '...' is not recognized as an internal or external command;Linux 的 shell 通常是 127。execFile 直接抛 ENOENT,没有 stderr。排查时先看错误形态,能区分「命令没找到」和「命令运行后失败」。
spawn 也可以设 shell: true,这时它和 exec 一样经过 shell,参数拼接的规则也回来了。Windows 上 shell 是 cmd.exe,路径带空格时不加引号会被拆开。默认不要开 shell,除非确实需要管道、重定向或通配符。
spawn 的 error 事件和 exit 是两回事。命令没找到、没有执行权限、参数类型不对,都会走 error,之后可能还会走一次 exit。只监听 exit 会把「没启动起来」当成「启动后退出」,错误码也对不上。
fork 与 IPC:消息不是原样送达
fork(modulePath) 启动一个新的 Node 进程,执行指定的模块文件,同时自动建立一条 IPC 通道。父进程用 child.send(msg) 发,子进程用 process.on('message') 收;反过来子进程 process.send(),父进程监听 child.on('message')。
const child = fork('./worker.cjs');
child.send({ n: 21 });
child.on('message', (m) => console.log('parent got', m));
// parent got { doubled: 42, pid: 48436 }
消息不是「同一个对象传过去」,而是序列化后再反序列化。默认用 JSON 序列化,所以类型会丢。我实测发一个 Date、一个函数、一个 Map 过去,子进程收到的是:dateType 'string'、isDate false、fnType 'undefined'、mapType '[object Object]'。日期变成了字符串,函数直接消失,Map 变成了普通对象。
fork 还能传第二个参数给子进程:fork(file, ['crash'], { silent: true })。silent 为 true 时子进程的 stdout/stderr 不直接打到父进程终端,而是变成可读流,父进程可以收集。做日志归集或测试时用这个,避免多个子进程的输出混在一起。
IPC 通道本身也有背压。child.send() 返回布尔值,和流的 write 一样,false 表示通道忙,应该等回调或降低发送频率。高频发送大消息时不管返回值,父进程内存会涨。
fork 返回的 ChildProcess 是一个 EventEmitter,除了 message、exit、close,还有 error。启动失败(比如模块路径不存在)不会走 exit,而是走 error,错误码通常是 ENOENT。两种事件都要监听,否则「启动失败」会被当成「进程静默退出」。
child.connected 表示 IPC 通道是否还连着。调用 child.disconnect() 会关闭通道,子进程随后可能因为事件循环空了而退出。要做「优雅重启」时,先 disconnect 让旧的停止接新消息,再 fork 新的,最后再杀旧的,比直接 kill 平滑。
IPC 消息是异步的,发送顺序和到达顺序一致,但不是「发出去就立刻到」。child.send(msg, callback) 的回调在消息真正写入通道后触发,要确保送达再继续,可以等这个回调。高频发送时,回调还兼做节流信号。
IPC 通道断开后,child.send() 会报 ERR_IPC_CHANNEL_CLOSED。父进程重启子进程前,先把旧的引用清掉,否则往已关闭的通道发消息只会得到错误。这个错误也要监听,不然会变成未捕获异常。
子进程的生命周期:退出、信号与崩溃
子进程有两个结束事件:exit 在进程本身结束时触发,close 在进程结束且所有 stdio 流关闭后触发。只监听 exit 可能拿不到最后一段输出,因为流还没读完;要等输出完整,监听 close。
child.kill(signal) 默认发 SIGTERM。我实测父进程调用 child.kill(),exit 事件的参数是 code null、signal 'SIGTERM'。注意「发出信号」不等于「进程已经退出」,信号只是请求,子进程可以捕获后继续运行。kill 返回 true 也只表示信号发出去了。
子进程崩溃时,父进程收到 exit,code 是 1,signal 是 null。我让子进程里抛一个异常,父进程打印的就是 crash exit 1 null,stderr 第一行是子进程文件的路径。父进程不会自动重启它,也不会自动退出;要不要重启、重启几次、怎么退避,都得自己写。
Windows 上信号支持有限。SIGTERM 实际走的是终止进程的接口,子进程不一定有机会做清理;SIGINT 在控制台里可用,但跨进程发送不一定生效。要「优雅关闭」,更可靠的方式是通过 IPC 发一条「请退出」的消息,子进程自己关连接、存状态,再 process.exit(0)。
子进程对象上还有 exitCode 和 signalCode,进程没结束时都是 null。child.killed 只表示「kill 被调用过」,不表示进程真的死了,别用它判断存活。真要判断,维护自己的状态,在 exit 或 close 里更新。
子进程里的 process.exit(0) 是「立刻结束」,process.exitCode = 0 是「把退出码记下来,等事件循环自然结束再退」。后者允许挂起的异步操作收尾。要保证日志刷完、连接关闭,用设置 exitCode;要强制中断,才用 exit()。
cluster:共享端口与自动重启的真相
cluster 是建在 child_process.fork 之上的一层封装。主进程(primary)负责 fork,worker 里执行同样的文件,但 cluster.isPrimary 是 false。多个 worker 可以监听同一个端口,连接由主进程分发给它们,看起来像「一个端口、多个进程」。
if (cluster.isPrimary) {
cluster.fork();
cluster.fork();
} else {
http.createServer((req, res) => res.end(String(process.pid)))
.listen(18888, '127.0.0.1');
}
我实测两个 worker 都打印 listening 18888,pid 分别是 8768 和 49448,端口确实是共享的。关键在「显式写同一个端口」:如果写成 listen(0),每个 worker 会各自拿到不同的随机端口(我实测 18829 和 18830),共享机制不生效,请求只会落到其中一个。
cluster 不会自动重启崩溃的 worker。它只会在 cluster.on('exit') 里通知你,重启逻辑要自己写。常见的写法是收到 exit 就 cluster.fork(),但要加次数限制和延迟,否则一个必崩的 worker 会被无限重启,日志刷屏、CPU 空转。
还有一个容易混淆的点:worker 之间不共享内存。cluster 的 worker 是独立进程,各自有堆和事件循环,全局变量不互通。要共享状态只能走外部存储或 IPC,不能靠「在 primary 里改个变量」。
cluster 的分发策略在不同平台上不一样。Linux 上默认是主进程轮询接受连接再分发,Windows 上更多依赖操作系统把连接交给某个 worker。所以「请求分布是否均匀」不能只看本地,压测要在目标平台做。
worker 里可以用 cluster.worker.id 区分实例,这个 id 从 1 开始,比 pid 更适合写进日志前缀。需要把任务定向发给某个 worker 时,cluster.workers 是一个以 id 为键的对象,可以拿到对应的 worker 再 send()。
cluster 的 primary 本身也占一个进程和一份内存,但它通常不处理业务。它挂掉,所有 worker 都会失去管理,所以 primary 的逻辑要尽量薄:只 fork、只记录、只重启,不要把业务代码放进去。
cluster.isPrimary 在旧代码里可能写成 cluster.isMaster,两者是同一个值。我实测 isMaster === isPrimary 为 true。新代码用 isPrimary,看到老代码里的 isMaster 不用困惑。调度策略可以用 cluster.setupPrimary({ schedulingPolicy: 'rr' }) 设置。
调度策略也可以用常量设置:cluster.schedulingPolicy = cluster.SCHED_RR 是轮询,SCHED_NONE 是交给操作系统。这个设置要在 fork 之前完成,fork 之后再改不生效。默认值随平台不同,跨平台项目最好显式写清。
现象对照
| 现象 | 真实原因 | 第一步查什么 |
|---|---|---|
| cluster 起了多个 worker,只有一个核忙 | listen(0) 让每个 worker 绑了不同端口 | 改成显式同一个端口,确认日志里的 port |
ENOENT | 命令不在 PATH,或路径写错 | 用绝对路径执行,确认文件存在 |
ERR_CHILD_PROCESS_STDIO_MAXBUFFER | exec 的输出超过 maxBuffer | 换 spawn 流式读,或调大上限 |
| IPC 收到的日期变成字符串 | 默认 JSON 序列化不保留类型 | 发送前转纯数据,接收端还原 |
IPC 收到的函数是 undefined | 函数无法序列化 | 改为传消息类型,让子进程自己选函数 |
kill() 返回 true 但进程还在 | 信号只是请求,子进程可以捕获 | 等 exit 事件,或超时后强杀 |
| 子进程崩了服务没恢复 | cluster 不会自动重启 | 在 exit 里 fork,并限制次数 |
只监听 exit 丢最后一段日志 | stdio 流还没读完 | 改监听 close |
| Windows 上优雅关闭不生效 | 信号支持有限 | 改用 IPC 发退出消息 |
| 发送大消息后父进程内存上涨 | child.send() 也有背压 | 看返回值,等回调再发下一批 |
边界与代价
多进程的第一个代价是「内存不共享」。父进程缓存的数据,子进程看不到;每个 worker 都要自己建连接池、自己加载模块,内存是成倍增加的。起 8 个 worker,基础内存就是 8 份。进程数不是越多越好,要按核数和内存算。
第二个代价是「通信成本」。IPC 要序列化、要跨进程拷贝,比函数调用慢几个数量级。把高频小消息拆成很多次发送,开销会很明显;正确做法是批量发送,或者把需要频繁共享的数据放到同一个进程里处理。
第三个代价是「生命周期管理」。启动顺序、健康检查、崩溃重启、优雅退出,每一项都要自己实现。cluster 只提供了 fork 和共享端口,不是进程管理器。真正生产上还需要外部工具监控和拉起,这属于部署范畴,这里不展开。
第四个代价是「调试更难」。多进程下日志交错,断点只能挂在其中一个进程,复现问题要指定 pid。实践里至少给每条日志带上 pid,最好再用一个请求 id 串起来。没有这两个字段,多进程日志基本没法读。
进程数还要考虑内存。假设一个 worker 常驻 80 MB,12 个就是接近 1 GB,再加上请求峰值时的临时对象,很容易触到容器上限。先测单个 worker 的稳定内存,再乘进程数,留 30% 余量,比拍脑袋定数量可靠。
重启策略要有上限。常见做法是记录连续失败次数,超过阈值就停止重启并上报;间隔从 100 毫秒开始翻倍,避免崩溃循环把 CPU 占满。一个持续崩的 worker,重启一万次也不会好,只会掩盖根因,还白白消耗 CPU。
小结
Node 单进程只能用一个核,多核要靠多进程;spawn 流式、不走 shell,exec 缓冲、走 shell,execFile 缓冲、不走 shell,fork 额外带 IPC;exec 的输出受 maxBuffer 限制,超了报 ERR_CHILD_PROCESS_STDIO_MAXBUFFER;IPC 默认 JSON 序列化,Date、Map、函数都会变形;kill 只是发信号,退出要等 exit;cluster 共享端口必须显式写同一个端口,listen(0) 会各绑各的;worker 崩了不会自动重启。
当天可以自己验证的练习:
- 用
fork起一个子进程,父进程发{ n: 21 },子进程回{ doubled: 42, pid }。 - 通过 IPC 发一个
Date和一个函数,打印子进程收到的类型。 - 让子进程抛异常,观察父进程收到的
exit参数和stderr内容。 - 用
exec输出超过 1 MB 的内容,确认错误码和stdout长度。 - 写一个
listen(0)的 cluster,再改成固定端口,对比两次的端口日志。
下一篇讲多线程:worker_threads、共享内存与消息传递。进程隔离好但重,线程轻但危险。Node 的 worker_threads 介于两者之间:同一个进程内开多个 JS 执行线程,既能共享内存,又各有自己的事件循环。什么时候该用线程而不是进程,下一篇用实测数据对比。