罗罗编程学习记录
本页内容 展开查看

07.2 阶段 1:运行时原理与核心 API

所属:全栈开发面试题库 / 学习路径 / 07 Node.js 全栈

本页目录

一、阶段定位

阶段 0 只解决了"JavaScript 异步代码怎么写",本阶段解决"Node 运行时到底按什么顺序跑这些代码"。核心是三件事:V8 负责执行 JS,libuv 负责异步 IO 与事件循环,事件循环决定了同步代码、微任务、定时器、IO 回调的先后顺序。这一层说不清,后面写 Web 服务时遇到"为什么接口突然变慢""为什么内存涨上去不下来"就没有分析工具。

与前后阶段的衔接:往上接 阶段 0 环境与 JavaScript 基础,那里你已经能写 Promise 并判断一次同步/微任务/宏任务的顺序;本阶段把这个顺序展开到 Node 内部的六个阶段,并解释 process.nextTick 为什么比 Promise 还早。往下接 阶段 2 模块体系与包管理,模块加载本身也是在事件循环启动前完成的,理解加载顺序才能看懂循环依赖。

本阶段原有的三个卡点,展开成可判断的现象依据:

  1. 把线程池当成主线程并发。判断标准:认为 fs.readFile 这类异步 API 会让 JS"并行"跑多段代码;认为 worker_threads 和 cluster 是同一回事;被问到"为什么 CPU 密集任务要挪到线程"时答不上来。实际上 libuv 线程池(默认 4 个)只跑文件 IO、DNS 解析、加密等原生任务,JS 代码始终在主线程一个线程上跑。
  2. 不理解背压导致管道内存暴涨。判断标准:用 readable.pipe(writable) 拷贝大文件,内存占用一路涨到文件大小;或者直接 readFile 整个读入再 write。这说明你没意识到生产速度 > 消费速度时缓冲区会无界增长。
  3. 以为异步 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 可改。
  • 事件循环每一轮按固定顺序走六个阶段:
    1. timers:执行到期的 setTimeout / setInterval 回调。
    2. pending callbacks:执行上一轮延迟到这一轮的系统错误回调(如 TCP ECONNRESET)。
    3. idle, prepare:内部使用。
    4. poll:等待新的 IO 事件,执行 IO 回调(绝大多数文件/网络回调在这里)。这是事件循环停留最久的阶段。
    5. check:执行 setImmediate 回调。
    6. close callbacks:执行 socket.on('close', ...) 之类的关闭回调。
  • 每两个阶段切换之间(更准确地说,在当前阶段的同步代码跑完后),会清空微任务队列:先清空所有 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 分钟内给出排查路径

自测题:

  1. 事件循环六个阶段的顺序是什么?微任务在哪两个阶段之间清空?
    • 要点:timers → pending callbacks → idle/prepare → poll → check → close;每个阶段切换前清空 nextTick 再清空 Promise。
  2. 在 fs.readFile 回调里写 setTimeout(0) 与 setImmediate,谁先执行?为什么?
    • 要点:setImmediate 先。因为 readFile 回调在 poll 阶段执行完后,事件循环进入 check 阶段执行 setImmediate,下一轮才到 timers 执行 setTimeout。
  3. process.nextTick 里不停加任务会怎样?
    • 要点:poll 阶段永远进不去,IO 全部排队;应改用 setImmediate 让出阶段。
  4. 为什么 fs.readFileSync 用在 HTTP 接口里会变慢?
    • 要点:同步 API 在主线程执行,卡住事件循环,所有其他请求排队等待。
  5. pipeline 相比 pipe 多了什么?
    • 要点:错误传播、自动清理、完成回调;pipe 不处理下游错误也不传递 err。
  6. Buffer.from("你好").length 是多少?为什么?
    • 要点:6。UTF-8 中文一个汉字 3 字节,两个汉字 6 字节。
  7. cluster 和 worker_threads 都是"多核利用",本质区别是什么?
    • 要点:cluster 是多进程(独立 V8、独立内存、fork 预共享端口),worker_threads 是真多线程(同一 V8、共享内存)。