07.2 阶段 1:运行时原理与核心 API
所属:全栈开发面试题库 / 学习路径 / 07 Node.js 全栈
本页目录
一、阶段定位
阶段 0 只解决了"JavaScript 异步代码怎么写",本阶段解决"Node 运行时到底按什么顺序跑这些代码"。核心是三件事:V8 负责执行 JS,libuv 负责异步 IO 与事件循环,事件循环决定了同步代码、微任务、定时器、IO 回调的先后顺序。这一层说不清,后面写 Web 服务时遇到"为什么接口突然变慢""为什么内存涨上去不下来"就没有分析工具。
与前后阶段的衔接:往上接 阶段 0 环境与 JavaScript 基础,那里你已经能写 Promise 并判断一次同步/微任务/宏任务的顺序;本阶段把这个顺序展开到 Node 内部的六个阶段,并解释 process.nextTick 为什么比 Promise 还早。往下接 阶段 2 模块体系与包管理,模块加载本身也是在事件循环启动前完成的,理解加载顺序才能看懂循环依赖。
本阶段原有的三个卡点,展开成可判断的现象依据:
- 把线程池当成主线程并发。判断标准:认为
fs.readFile这类异步 API 会让 JS"并行"跑多段代码;认为worker_threads和cluster是同一回事;被问到"为什么 CPU 密集任务要挪到线程"时答不上来。实际上 libuv 线程池(默认 4 个)只跑文件 IO、DNS 解析、加密等原生任务,JS 代码始终在主线程一个线程上跑。 - 不理解背压导致管道内存暴涨。判断标准:用
readable.pipe(writable)拷贝大文件,内存占用一路涨到文件大小;或者直接readFile整个读入再write。这说明你没意识到生产速度 > 消费速度时缓冲区会无界增长。 - 以为异步 API 都不阻塞,误用同步 fs 方法在请求路径上。判断标准:在 HTTP 接口里写
fs.readFileSync、crypto.pbkdf2Sync、JSON.parse(JSON.stringify(big)),请求量上来后 P99 飙升,因为同步 API 会卡住事件循环整个阶段。
二、阶段目标与投入
学完本页,应当能用可观察的行为证明以下能力:
| 能力目标(可验证的行为) | 验证方式 |
|---|---|
| 能画出事件循环六个阶段并说出微任务在哪两个阶段之间清空 | 手写一段含 nextTick、Promise.then、setTimeout、setImmediate 的代码,预判输出 |
能区分 setTimeout(fn,0) 与 setImmediate(fn) 在主模块内与 I/O 回调中的先后 |
两个场景各跑一遍并解释差异 |
| 能判断一段代码是否阻塞事件循环,并说出同步 fs 为什么会卡住服务 | 写一个故意阻塞的接口,观察其他接口排队 |
能用 stream.pipeline 流式拷贝大文件,处理背压错误 |
拷贝 1GB 文件,内存驻留稳定在几 MB 而非涨到文件大小 |
| 能解释 EventEmitter 默认 10 个监听器上限,写出一个泄漏监听器的复现 | 触发 MaxListenersExceededWarning 并修掉 |
能用 child_process.spawn 起子进程,能说清 exec 与 spawn 的区别 |
写一个执行 git log 的小工具,按行读输出 |
建议学时:
- 全职(每天 4–6 小时):2 周,约 60 小时。事件循环 15 小时、Buffer 与 fs 10 小时、Stream 与背压 15 小时、EventEmitter 8 小时、child_process/worker_threads/cluster 12 小时。
- 在职(每天 2 小时、周末补 4 小时):5–6 周,约 65 小时。事件循环与 Stream 是面试重灾区,时间要给够。
学时分配建议:事件循环与微任务 25%、阻塞与同步 API 15%、Buffer 10%、Stream 与背压 25%、EventEmitter 10%、子进程与多线程 15%。
三、先修自检
| 先修项 | 合格标准 | 不合格时回到 |
|---|---|---|
| JavaScript 异步 | 能写 async/await、用 try/catch 捕获 reject | 07.1 阶段 0 环境与 JavaScript 基础 |
| 同步/微任务/宏任务顺序 | 能预判 console.log + Promise.then + setTimeout 的输出 |
07.1 阶段 0 |
| Node 基本运行 | node script.js、node -v 正常 |
07.1 阶段 0 |
| 命令行与文件操作 | 能建目录、写文件、看进程 | 07.1 阶段 0 |
| HTTP 概念 | 知道请求-响应、状态码 | 01.2 计算机网络 |
四、知识地图
| 模块 | 知识点 | 掌握程度 | 对应题库章节 |
|---|---|---|---|
| 运行时组成 | V8 JIT、libuv、线程池 UV_THREADPOOL_SIZE、事件循环 | 能讲清原理 | 04.2 Node.js |
| 事件循环六阶段 | timers / pending callbacks / idle,prepare / poll / check / close | 能讲清原理 | 04.2 Node.js |
| 微任务 | process.nextTick、Promise.then、queueMicrotask、清空时机 |
能讲清原理 | 04.2 Node.js |
| 定时器 | setTimeout、setImmediate、在主模块与 I/O 回调中的先后 |
会用 | 04.2 Node.js |
| fs 与路径 | fs.readFile/readFileSync/createReadStream、path、__dirname |
会用 | 04.2 Node.js |
| Buffer | Buffer.from、alloc、编码、拼接、Buffer.concat |
会用 | 04.2 Node.js |
| Stream | 四种流、pipe、pipeline、背压、highWaterMark |
能讲清原理 | 04.2 Node.js |
| EventEmitter | on/off/emit、setMaxListeners、泄漏警告 |
会用 | 04.2 Node.js |
| 多进程多线程 | child_process.spawn/exec/fork、worker_threads、cluster |
会用 | 04.2 Node.js |
进度管理建议:事件循环与 Stream 两块必须到"能讲清原理",其余到"会用"。《知识点全清单》是全量清单,本表只列本阶段重点。
五、分模块精讲
5.1 V8、libuv 与事件循环六阶段
为什么需要它:Node 不是"多线程 JS",而是"单线程 JS + 事件循环 + 线程池"。理解这个模型,才能解释为什么一段同步 CPU 密集代码会让整个服务变慢,为什么异步 IO 却能支撑高并发。
核心机制:
- V8:Google 开源的 JS 引擎,负责解析、编译(JIT)、执行 JS 并管理堆内存。Node 把 V8 的事件循环接口换成了 libuv 实现。
- libuv:跨平台异步 IO 库。内部维护一个事件循环、一个默认大小 4 的线程池(文件 IO、DNS、
crypto.pbkdf2、zlib等用它),通过环境变量UV_THREADPOOL_SIZE可改。 - 事件循环每一轮按固定顺序走六个阶段:
- timers:执行到期的
setTimeout/setInterval回调。 - pending callbacks:执行上一轮延迟到这一轮的系统错误回调(如 TCP ECONNRESET)。
- idle, prepare:内部使用。
- poll:等待新的 IO 事件,执行 IO 回调(绝大多数文件/网络回调在这里)。这是事件循环停留最久的阶段。
- check:执行
setImmediate回调。 - close callbacks:执行
socket.on('close', ...)之类的关闭回调。
- timers:执行到期的
- 每两个阶段切换之间(更准确地说,在当前阶段的同步代码跑完后),会清空微任务队列:先清空所有
process.nextTick队列,再清空 Promise 微任务队列。这个过程会递归进行——如果微任务里又加了 nextTick,会继续清,直到队列为空才进入下一个阶段。
最小可运行示例:
// 预判输出:理解六个阶段与微任务清空时机
console.log("1 同步开始");
setTimeout(() => console.log("2 setTimeout(0)"), 0);
setImmediate(() => console.log("3 setImmediate"));
Promise.resolve().then(() => console.log("4 Promise.then"));
process.nextTick(() => console.log("5 process.nextTick"));
console.log("6 同步结束");
// 在主模块直接运行,输出顺序:
// 1 同步开始
// 6 同步结束
// 5 process.nextTick <- 微任务阶段先于 timers
// 4 Promise.then <- nextTick 队列清空后才到 Promise
// 2 setTimeout(0) <- timers 阶段
// 3 setImmediate <- check 阶段(在 timers 之后)
# 观察线程池大小
node -e "console.log('线程池:', process.env.UV_THREADPOOL_SIZE || 4)"
# 修改:UV_THREADPOOL_SIZE=8 node script.js
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
setTimeout(fn,0) 与 setImmediate(fn) 在主模块里先后不确定 |
受进程启动耗时影响,timer 可能先到也可能后到 | 在 I/O 回调里对比:setImmediate 一定先于 setTimeout(0) |
| 异步 IO 看起来"并行"了 JS | 实际是事件循环在一个线程上切换任务,不是真并行 | CPU 密集用 worker_threads,不要靠 async API |
| 线程池打满,文件 IO 排队 | 默认线程池只有 4 个 | 调大 UV_THREADPOOL_SIZE,或改用流式读取 |
| 微任务里不停加 nextTick,事件循环卡死 | nextTick 队列被持续塞满,永远到不了 poll 阶段 | 用 setImmediate 让出,避免在 nextTick 里做长任务 |
面试考法:必考题"事件循环有哪几个阶段""nextTick 和 Promise.then 谁先""setTimeout(0) 和 setImmediate 谁先"。标准答案要讲到:nextTick 在 Promise 之前、在当前阶段结束后立即清空;主模块里两者先后不确定,但 I/O 回调里 setImmediate 一定先于 setTimeout(0)。
5.2 微任务与定时器优先级
为什么需要它:微任务队列的清空时机是 Node 与浏览器行为最容易混的地方。把它搞清楚,才能解释为什么 await 之后的代码、.then 回调、process.nextTick 回调会插在你不期望的位置执行。
核心机制:
- 微任务队列分两档:
process.nextTick队列(最高优先级)和 Promise 微任务队列(其次)。每轮同步代码结束后,Node 先把 nextTick 队列清空到空,再清空 Promise 队列;这两个过程都会递归处理新加入的微任务。 setTimeout(fn, 0)的实际延迟不是 0,Node 内部最小约 1ms(嵌套定时器还有更严格的 4ms 钳制,遵循 HTML 规范)。setImmediate设计目的就是"在 I/O 事件之后、下一个阶段之前执行",所以它在 check 阶段执行,永远比 I/O 回调里的 setTimeout(0) 早。queueMicrotask(fn)是标准的 Promise 微任务等价物,行为与Promise.resolve().then(fn)一致,但比process.nextTick优先级低。
最小可运行示例:
const fs = require("fs");
// 在 I/O 回调里对比 setImmediate 与 setTimeout(0)
fs.readFile(__filename, () => {
setTimeout(() => console.log("A: setTimeout(0)"), 0);
setImmediate(() => console.log("B: setImmediate"));
process.nextTick(() => console.log("C: nextTick"));
Promise.resolve().then(() => console.log("D: Promise"));
});
console.log("主模块同步结束");
// 主模块同步结束
// C: nextTick <- I/O 回调执行完,先清 nextTick
// D: Promise <- 再清 Promise
// B: setImmediate <- check 阶段,一定在 A 之前
// A: setTimeout(0)
// nextTick 递归加任务会卡死事件循环
let i = 0;
function loop() {
i++;
if (i < 100000) process.nextTick(loop); // 短时间内没事
else console.log("done", i);
}
loop();
// 注意:如果在 nextTick 里做重活,poll 阶段永远进不去,IO 全部排队
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
process.nextTick 里加任务,定时器永远不触发 |
nextTick 队列被持续塞满 | 改用 setImmediate 让出阶段 |
| 浏览器里 nextTick 不存在 | Node 专有 API | 同构代码用 queueMicrotask |
setTimeout(fn, 0) 实际延迟是 1ms 而非 0 |
Node 内部有最小延迟钳制 | 要"尽快"用 setImmediate 或 queueMicrotask |
await 之后的代码看似"同步"地插队 |
await 把后续代码变成微任务 | 理解 await 是让出主线程,不是阻塞 |
面试考法:"nextTick 与 Promise.then 的区别""为什么不要在 nextTick 里做重活"。答到:nextTick 优先级最高、会在任何 I/O 前清空,用多了会饿死 poll 阶段;它适合"在当前操作完成后、下一个阶段前"做拦截与修复。
5.3 阻塞判定与同步/异步 fs
为什么需要它:事件循环是单线程的,任何一段同步代码都会卡住所有其他请求。生产环境最常见的事故不是"代码写错了",而是"在请求路径上用了同步 API"。
核心机制:
- 阻塞事件循环的代码:长 for 循环、
JSON.parse大字符串、crypto.pbkdf2Sync、fs.readFileSync、zlib.gzipSync、正则回溯。它们都在主线程上跑,期间 timers、poll、check 全部停摆。 - 不阻塞的:
fs.readFile(异步,线程池)、http.createServer(网络 IO)、setTimeout(定时器)、worker_threads(真并行)。 - 同步 API 的合法用途:启动阶段读配置、CLI 脚本、写一次性工具。一旦在 HTTP 请求路径上,就是事故。
- 判定指标:事件循环延迟(event loop lag)、CPU 使用率、P99 延迟。
clinic doctor会直接给出"blocked event loop"报告。
最小可运行示例:
const http = require("http");
const fs = require("fs");
const server = http.createServer((req, res) => {
if (req.url === "/block") {
// 错误示范:同步读 10MB 文件,阻塞整个事件循环约 50ms
const buf = fs.readFileSync("/tmp/big.bin");
res.end("ok " + buf.length);
} else if (req.url === "/nonblock") {
// 正确:异步读,让出事件循环
fs.readFile("/tmp/big.bin", (err, buf) => {
if (err) { res.statusCode = 500; return res.end(String(err)); }
res.end("ok " + buf.length);
});
} else {
res.end("ping");
}
});
server.listen(3000);
// 压测:先打 /block 一次,再连续打 /ping,会发现 /ping 也卡住了几十毫秒
// 启动阶段用同步 API 是合理的
const config = JSON.parse(fs.readFileSync("./config.json", "utf8"));
// 但请求处理函数里禁止这样写
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
| 压测 P99 飙升,CPU 不高 | 事件循环被同步代码卡住 | 用 clinic doctor 定位;换异步 API |
fs.readFileSync 在接口里 |
同步读文件阻塞循环 | 改 fs.readFile 或流式 createReadStream |
crypto.pbkdf2Sync 校验密码慢 |
故意设计成慢(防暴力破解),但同步阻塞 | 用 crypto.pbkdf2 异步版本,或挪到 worker_threads |
JSON.parse 大 JSON 卡 |
V8 解析大字符串是同步 CPU 任务 | 拆小、用流式 JSON parser(如 JSONStream) |
面试考法:"怎么判断一段代码阻塞事件循环""同步 API 能不能用"。答到:能让事件循环测量工具看到 lag 升高的就是阻塞;同步 API 只在启动/CLI 用,请求路径上禁用。
5.4 Buffer 与二进制处理
为什么需要它:JS 没有原生字节类型,Node 用 Buffer(Uint8Array 的子类)处理 TCP 流、文件、图片、加密结果。不理解 Buffer,流式处理时拼接字节就会出现乱码、长度错误。
核心机制:
Buffer.from(str, "utf8")把字符串编码成字节;buf.toString("utf8")解码。Buffer 的长度是字节数,不是字符数。Buffer.alloc(n)分配清零的 n 字节;Buffer.allocUnsafe(n)分配但不清零(更快但可能含旧数据,使用前必须写入)。- 中文 UTF-8 一个汉字 3 字节,所以
Buffer.from("你好").length是 6,不是 2。 - 多个 Buffer 拼接用
Buffer.concat([buf1, buf2]),不要buf1 + buf2(会隐式 toString,可能丢字节)。 - 流的
data事件每次给一个 Buffer 片段,长消息会被切成多段,应用层要自己拼包。
最小可运行示例:
const buf = Buffer.from("你好", "utf8");
console.log(buf.length); // 6,不是 2
console.log(buf.toString("utf8")); // 你好
console.log(buf.toString("hex")); // e4bda0e5a5bd
// 错误:直接 + 拼接 Buffer
const a = Buffer.from("你", "utf8");
const b = Buffer.from("好", "utf8");
console.log(a + b); // 你好(隐式 toString,碰巧对)
console.log(Buffer.concat([a, b]).toString("utf8")); // 你好(正确)
// 分配与安全
const safe = Buffer.alloc(10); // 全 0
const fast = Buffer.allocUnsafe(10); // 可能含旧数据,必须立即写满
fast.fill(0);
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
| Buffer 长度比字符数大 | UTF-8 多字节字符 | 用 Buffer.byteLength(str) 算字节,[...str] 数字符 |
| 流式读出来的中文乱码 | 字符被从中间切断 | 用 StringDecoder,或按消息边界(长度前缀)拼包 |
allocUnsafe 内容有旧数据 |
内存复用未清零 | 使用前 fill(0),或直接 alloc |
两个 Buffer === 为 false |
Buffer 是对象,引用比较 | 用 Buffer.compare(a, b) 或 a.equals(b) |
面试考法:"Buffer 与 Uint8Array 的关系""为什么流的 data 事件会切碎消息"。答到 Buffer 是 Uint8Array 的子类、有Node 专用的二进制 API;TCP 是字节流没有消息边界,应用层必须自己定界。
5.5 Stream 与背压
为什么需要它:文件、网络、压缩在 Node 里都是"流"。一次性读入大文件会 OOM,而不处理背压会让生产者速度超过消费者导致内存暴涨。pipeline 是 Node 官方推荐的标准写法。
核心机制:
- 四种流:
Readable(读,如fs.createReadStream)、Writable(写,如fs.createWriteStream)、Duplex(读写,如 TCP socket)、Transform(读-改-写,如zlib.createGzip)。 highWaterMark:每个流的内部缓冲水位线,默认 64KB(Readable)或 16KB(Writable)。- 背压:当 Writable 缓冲区达到水位线,
write()返回false,Readable 应暂停,等 Writable 触发drain事件再继续。pipe与pipeline自动处理这个过程。 readable.pipe(writable)是老写法,错误处理与完成事件不完整;stream.pipeline(readable, transform, writable, callback)是现代写法,自动清理、传错、触发完成回调。pipeline的回调收到err时表示整条管道失败,必须处理。
最小可运行示例:
const { pipeline } = require("stream");
const { createReadStream, createWriteStream } = require("fs");
const { createGzip } = require("zlib");
// 流式拷贝并压缩一个 1GB 文件:内存驻留约几 MB
pipeline(
createReadStream("big.bin"),
createGzip(),
createWriteStream("big.bin.gz"),
(err) => {
if (err) {
console.error("管道失败:", err.message);
} else {
console.log("完成");
}
}
);
// 错误写法:一次性读入,1GB 文件内存涨到 1GB
const fs = require("fs");
fs.readFile("big.bin", (err, buf) => {
fs.writeFile("big.copy.bin", buf, () => {}); // buf 是 1GB
});
// 手动观察背压
const rs = createReadStream("big.bin", { highWaterMark: 64 * 1024 });
rs.on("data", (chunk) => {
console.log("收到字节:", chunk.length);
// 实际生产用 pipeline,不要手动写 data 事件
});
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
| 大文件拷贝内存涨到文件大小 | 用 readFile 或手动 data 事件不处理背压 |
改用 pipeline |
pipe 后下游报错,上游没停 |
老 pipe 不传递错误 | 改用 pipeline,在回调里处理 err |
| 压缩出来的 gz 损坏 | 管道中途断了没报错 | pipeline 回调必须处理 err |
| highWaterMark 设太大 | 缓冲过大内存涨 | 保持默认,按业务调 |
面试考法:"什么是背压,为什么会发生""pipe 和 pipeline 的区别"。答到:生产 > 消费时 Writable 缓冲区积压,pipeline 自动暂停上游并在 drain 时恢复;pipeline 比 pipe 多了错误传播与清理。
5.6 EventEmitter 与监听器泄漏
为什么需要它:Node 的核心模块(http.Server、fs.ReadStream、process)都基于 EventEmitter。理解它才能写自定义事件、排查"为什么监听器触发了 N 次"。
核心机制:
on(event, listener)注册监听,emit(event, ...args)触发,off(event, listener)移除。- 默认每个事件最多 10 个监听器,超过触发
MaxListenersExceededWarning。这不是错误,是提示泄漏。 once(event, listener)只触发一次后自动移除。- 监听器泄漏的典型场景:在循环或请求处理里
on("data", ...),但没有在结束时off,导致同一事件被重复注册。 emitter.setMaxListeners(n)可调整上限,但不能掩盖泄漏,只能放大问题。
最小可运行示例:
const { EventEmitter } = require("events");
const bus = new EventEmitter();
// 正确:注册一次,反复触发
bus.on("tick", (n) => console.log("tick", n));
bus.emit("tick", 1); // tick 1
bus.emit("tick", 2); // tick 2
// 错误示范:循环里反复注册
for (let i = 0; i < 15; i++) {
bus.on("data", () => console.log("data received"));
}
// 运行到第 11 个时触发 (node:xxx) MaxListenersExceededWarning
bus.emit("data");
// 移除:必须传同一个函数引用
const handler = () => console.log("msg");
bus.on("msg", handler);
bus.off("msg", handler); // 有效
// 匿名函数无法 off,因为引用对不上
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
(node:xxx) MaxListenersExceededWarning |
同一事件注册超过 10 个监听器 | 检查是否在循环里重复 on;用 off 清理 |
| 回调被执行了 N 次 | 重复注册没移除 | 用命名函数,在结束时 off |
off 不生效 |
传了匿名函数,引用对不上 | 把处理函数提为命名函数再 off |
setMaxListeners(0) 掩盖问题 |
关掉警告不解决泄漏 | 找泄漏源,不要简单调大上限 |
面试考法:"EventEmitter 默认上限是多少""怎么排查监听器泄漏"。答到 10;用 emitter.listenerCount(event) 看计数,在循环里找重复 on。
5.7 child_process、worker_threads 与 cluster
为什么需要它:Node 主线程只有一个,CPU 密集任务要么挪到子进程,要么挪到工作线程。理解三者分工,才能在多核机器上跑满 CPU。
核心机制:
child_process.exec(cmd, cb):起 shell 执行命令,缓冲全部输出,适合短命令。child_process.spawn(cmd, args):流式输出,不缓冲,适合长命令或大数据量;返回 ChildProcess 对象,可监听stdout/stderr。child_process.fork(modulePath):特殊的 spawn,专门起 Node 子进程,内置 IPC 通道(send/on('message'))。worker_threads:真正的多线程 JS,共享内存(SharedArrayBuffer),但线程间通信要结构化克隆。适合 CPU 密集计算。cluster:基于 fork,主进程监听端口,按轮询把请求分给多个 worker。适合利用多核跑 HTTP 服务,每个 worker 是独立 Node 进程。- 三者选择:外部命令用 spawn;CPU 计算用 worker_threads;多实例 HTTP 服务用 cluster(生产环境更常直接用容器多副本,见阶段 7)。
最小可运行示例:
const { spawn } = require("child_process");
// 流式执行 git log,按行读输出
const child = spawn("git", ["log", "--oneline", "-n", "5"]);
child.stdout.on("data", (data) => {
process.stdout.write(data);
});
child.on("close", (code) => {
console.log("退出码:", code);
});
const { Worker, isMainThread, parentPort } = require("worker_threads");
if (isMainThread) {
// 主线程:起 worker 做 CPU 密集计算
const w = new Worker(__filename);
w.on("message", (result) => console.log("worker 结果:", result));
w.postMessage(1000000);
} else {
// 工作线程:做求和
parentPort.on("message", (n) => {
let sum = 0;
for (let i = 0; i < n; i++) sum += i;
parentPort.postMessage(sum);
});
}
const cluster = require("cluster");
const numCPUs = require("os").cpus().length;
if (cluster.isPrimary) {
for (let i = 0; i < numCPUs; i++) cluster.fork();
} else {
require("http").createServer((req, res) => res.end("worker " + process.pid)).listen(3000);
}
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
exec 大输出被截断 |
缓冲默认 200KB | 改用 spawn 流式读 |
| 命令注入风险 | exec(userInput) 拼 shell |
用 spawn(cmd, args) 不经过 shell,参数数组传 |
worker 里 require 路径错 |
工作线程有独立 module 上下文 | 用 __filename 或绝对路径 |
| cluster 里 session 丢失 | 多进程内存不共享 | 用 Redis 存 session,不要内存存 |
面试考法:"spawn 与 exec 的区别""worker_threads 与 cluster 的区别""CPU 密集任务怎么处理"。答到:spawn 流式、exec 缓冲;worker_threads 是真多线程共享内存,cluster 是多进程预共享端口;CPU 密集挪到 worker_threads。
六、分层练习
6.1 复现型
| 练习 | 要求 | 验收标准 | 预计耗时 |
|---|---|---|---|
| 执行顺序实验 | 写含 nextTick/Promise/setTimeout/setImmediate 的代码,先预判后运行 | 预判与实际一致,能解释每个阶段 | 1 小时 |
| I/O 回调里对比定时器 | 在 fs.readFile 回调里写 setTimeout 与 setImmediate,验证先后 | setImmediate 一定先 | 0.5 小时 |
| 流式拷贝 | 用 pipeline 拷贝一个 100MB 文件 | 内存驻留几 MB,文件完整 | 1 小时 |
| Buffer 拼接 | 手动从流的 data 事件拼一个 Buffer 并 toString | 中文无乱码 | 1 小时 |
| 监听器泄漏复现 | 循环里 on 同一事件,触发 MaxListenersExceededWarning | 看到警告,用 off 修掉 | 0.5 小时 |
6.2 改造型
| 练习 | 要求 | 验收标准 | 预计耗时 |
|---|---|---|---|
| 修阻塞接口 | 把 readFileSync 接口改成异步 | 压测时 /ping 不再被 /block 影响 | 1 小时 |
| pipe 改 pipeline | 给定 rs.pipe(ws) 代码改成 pipeline |
错误回调能收到 err | 1 小时 |
| 大文件改流式 | 把 readFile + writeFile 改成 pipeline | 内存不再涨到文件大小 | 1 小时 |
| exec 改 spawn | 把 exec("git log " + branch) 改成 spawn 数组参数 |
不存在 shell 注入 | 1 小时 |
| 漏 off 修复 | 给定重复 on 的代码,用命名函数 + off 修掉 | 回调只执行一次 | 0.5 小时 |
6.3 设计型
| 练习 | 要求 | 验收标准 | 预计耗时 |
|---|---|---|---|
| 流式压缩服务 | 用 pipeline + gzip 实现"上传文件→压缩→返回" | 不读入内存,大文件 OOM 安全 | 4 小时 |
| 自定义 EventEmitter | 实现一个带"超时自动 remove"的事件总线 | 无监听器泄漏,listenerCount 可观测 | 3 小时 |
| CPU 密集计算卸载 | 把一个 100 万次循环挪到 worker_threads | 主线程不卡,其他请求正常 | 4 小时 |
| 多进程 HTTP 服务 | 用 cluster 起 4 个 worker,轮询请求 | 多次请求打到不同 pid | 3 小时 |
七、排障表
| 现象 | 可能原因 | 排查步骤 | 解决办法 |
|---|---|---|---|
| P99 高但 CPU 不高 | 事件循环被同步代码卡住 | clinic doctor 看 event loop lag |
换异步 API,挪走 CPU 任务 |
UnhandledPromiseRejection |
Promise 链无 catch | 从栈定位 await/then 位置 | 加 try/catch 或 .catch |
| 大文件操作内存暴涨 | 用了 readFile 或不背压 | 看 process.memoryUsage() 趋势 | 改用 pipeline |
MaxListenersExceededWarning |
重复注册监听器 | emitter.listenerCount() 看计数 |
找重复 on 点,用 off 清理 |
setTimeout(0) 延迟约 1ms |
Node 内部最小延迟 | 测量实际延迟 | 要"尽快"用 setImmediate |
| 中文流乱码 | 字符被从 Buffer 中间切断 | 打印 chunk 长度与 hex | 用 StringDecoder 或长度前缀拼包 |
| cluster 多副本 session 丢失 | 多进程内存不共享 | 看 session 存哪 | 挪到 Redis |
exec 输出被截断 |
缓冲超限 | 看 stderr 与错误码 | 改 spawn 流式读 |
八、出口条件
全部勾选后再进入 阶段 2 模块体系与包管理。
- [ ] 能画出事件循环六个阶段,说清 nextTick 与 Promise 的清空时机
- [ ] 能区分主模块与 I/O 回调中 setTimeout(0) 与 setImmediate 的先后
- [ ] 能写一个流式拷贝脚本,用 pipeline 处理 1GB 文件不 OOM
- [ ] 能解释 Buffer 字节长度与字符长度的差异,用 Buffer.concat 拼接
- [ ] 能复现并修掉一个 EventEmitter 监听器泄漏
- [ ] 能用 spawn 执行 git 命令按行读输出,说清与 exec 的区别
- [ ] 能把一段同步 CPU 密集代码挪到 worker_threads 并验证主线程不卡
- [ ] 排障表八个现象,随机抽三个能在 5 分钟内给出排查路径
自测题:
- 事件循环六个阶段的顺序是什么?微任务在哪两个阶段之间清空?
- 要点:timers → pending callbacks → idle/prepare → poll → check → close;每个阶段切换前清空 nextTick 再清空 Promise。
- 在 fs.readFile 回调里写 setTimeout(0) 与 setImmediate,谁先执行?为什么?
- 要点:setImmediate 先。因为 readFile 回调在 poll 阶段执行完后,事件循环进入 check 阶段执行 setImmediate,下一轮才到 timers 执行 setTimeout。
process.nextTick里不停加任务会怎样?- 要点:poll 阶段永远进不去,IO 全部排队;应改用 setImmediate 让出阶段。
- 为什么
fs.readFileSync用在 HTTP 接口里会变慢?- 要点:同步 API 在主线程执行,卡住事件循环,所有其他请求排队等待。
pipeline相比pipe多了什么?- 要点:错误传播、自动清理、完成回调;pipe 不处理下游错误也不传递 err。
- Buffer.from("你好").length 是多少?为什么?
- 要点:6。UTF-8 中文一个汉字 3 字节,两个汉字 6 字节。
- cluster 和 worker_threads 都是"多核利用",本质区别是什么?
- 要点:cluster 是多进程(独立 V8、独立内存、fork 预共享端口),worker_threads 是真多线程(同一 V8、共享内存)。