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

04.2.2.3 Stream、Buffer 与背压

所属:全栈开发面试题库 / 04 后端语言与运行时 / 04.2 Node.js / 04.2.2 工程化与性能诊断

04.2.2.3-001 Node 为什么需要 Buffer?

一句话结论

JS 原生字符串只有 Unicode 文本,无法直接操作二进制字节;Buffer 是 V8 堆外分配的字节数组,承载网络包、文件、加密等原始二进制数据。

概念解释

服务端频繁处理字节流:文件读写、TCP 报文、图片、压缩。Buffer 提供按索引读写字节、编码转换与二进制安全操作,避免把二进制强行当字符串损坏。

原理流程

  1. 底层 IO 返回字节序列。
  2. 包装为 Buffer 供 JS 操作。
  3. 需要文本时按编码解码为字符串。

代码或图示

const buf = Buffer.from('hello', 'utf8');
console.log(buf.length, buf[0]);

常见误区

  • 用字符串存二进制:多字节字符与编码转换会破坏字节边界。
  • Buffer 数据在 V8 堆内:Buffer 内存主要在堆外分配,GC 管理方式不同。

追问

  • 常用编码?答:utf8、base64、hex、latin1;解码错误会产生替换字符。
  • Buffer 与 Uint8Array 什么关系?答:Node Buffer 是 Uint8Array 的子类,额外提供编码转换、拼接、拷贝等方法。

04.2.2.3-002 Buffer 分配与池化有什么约定?

一句话结论

Buffer.alloc 初始化清零,Buffer.allocUnsafe 不清零(可能含旧内存,需立即覆写);较小的 Buffer.from 可能使用内部池以减少分配开销。

概念解释

allocUnsafe 跳过清零换取性能,但残留旧数据有安全与正确性风险;对外返回前必须写满。池化复用大块预分配内存,降低频繁分配成本。

原理流程

  1. 申请指定大小字节。
  2. alloc 清零;allocUnsafe 直接取内存。
  3. 写入数据后再使用,避免暴露残留。

代码或图示

const safe = Buffer.alloc(1024);
const fast = Buffer.allocUnsafe(1024);
fast.fill(0); // 立即覆写

常见误区

  • allocUnsafe 拿到的内容是零:它不清零,可能含旧字节。
  • 池化 Buffer 可随意共享:切片共享底层内存,修改会影响原 Buffer。

追问

  • 待确认:池化阈值与分配行为随版本调整,以当前文档为准。
  • alloc 与 allocUnsafe 区别?答:Buffer.alloc(size) 清零初始化;allocUnsafe 不清零,需先 fill 或写入覆盖旧字节。

04.2.2.3-003 流(Stream)解决什么问题?

一句话结论

流把大数据拆成小块逐段处理,避免一次性读入内存;边读边写,内存占用平稳,适合大文件、网络传输与转换管道。

概念解释

一次性 readFile/readBody 会把全部数据放进内存。流按块消费,生产与消费并行推进,内存不随总数据量线性膨胀。

原理流程

  1. 数据源产出小块数据。
  2. 经管道逐级转换/写入。
  3. 每段处理完再取下一段。

代码或图示

源 → 读流 → 转换流 → 写流(逐块推进,不整份入内存)

常见误区

  • 流只是异步文件 API:它是数据分段处理的抽象,覆盖网络、压缩、加密等场景。
  • 用流处理小数据更优:小数据直接缓冲更简单,流的价值在大体积/无限数据流。

追问

  • 流的四个抽象类型?答:Readable、Writable、Duplex、Transform。
  • 流的核心价值是什么?答:分段处理大体积或无限数据流,避免一次性把数据读进内存。

04.2.2.3-004 四种流类型分别是什么?

一句话结论

Readable 只读(源),Writable 只写(目的地),Duplex 双向可读可写,Transform 是输入经转换后输出的 Duplex。

概念解释

类型决定数据方向。压缩、加密、格式转换属于 Transform;TCP 套接字是 Duplex;文件可读流/可写流分别是 Readable/Writable。

原理流程

  1. Readable 产出 chunk。
  2. Writable 接收 chunk 写入。
  3. Transform 读入后变换再写出;Duplex 两侧独立。

代码或图示

Readable → Writable
Duplex:两端独立读写
Transform:输入 → 变换 → 输出

常见误区

  • Transform 与 Duplex 可互换:Transform 内置转换逻辑,Duplex 两侧无自动连接。
  • 所有流都能双向 pipe:方向由类型决定。

追问

  • 举例:gzip 是 Transform;socket 是 Duplex;HTTP 请求体是 Readable。
  • Duplex 与 Transform 区别?答:Duplex 可读可写但两侧独立;Transform 可读可写且写入经转换后读出。

04.2.2.3-005 Readable 有哪两种读取模式?

一句话结论

flowing 模式下数据自动流动并触发 data 事件;paused 模式下需手动 read() 拉取,默认进入 paused,监听 data 或 pipe 后切到 flowing。

概念解释

模式决定数据推送还是拉取。flowing 吞吐高但要处理背压;paused 由消费方控制节奏,适合按需读取。

原理流程

  1. 初始 paused。
  2. 监听 data/调用 pipe 进入 flowing。
  3. 移除 data 或调用 pause 回到 paused。

代码或图示

rs.on('data', (chunk) => { /* flowing */ });
rs.pause();
const chunk = rs.read(); // paused 手动拉取

常见误区

  • 两种模式可随意混用:切换时机影响数据是否丢失。
  • paused 模式不监听事件就有数据:必须 read() 拉取。

追问

  • 推荐消费方式?答:用 pipeline/异步迭代器,避免手动管理模式切换。
  • 两种读取模式是什么?答:flowing(data 事件自动推送)与 paused(read() 手动拉取);监听 data 会切到 flowing。

04.2.2.3-006 什么是背压(backpressure)?

一句话结论

上游产出速度快于下游消费速度时,写缓冲堆积;背压是下游通过返回 false 通知上游暂停,待缓冲排空后再恢复,防止内存被数据淹没。

概念解释

流内部有高水位线缓冲。持续快写会让缓冲无限增长,表现为内存上涨、延迟升高。背压机制让生产节奏跟随消费能力。

原理流程

  1. 写入方调用 write(chunk)。
  2. 缓冲超过 highWaterMark 时 write 返回 false。
  3. 上游暂停,等 drain 事件后再恢复写入。

代码或图示

if (!ws.write(chunk)) {
  ws.once('drain', () => /* 恢复写入 */);
}

常见误区

  • 只管 write 不看返回值:忽略背压会导致缓冲堆积。
  • 背压是网络协议概念:流背压发生在生产消费节奏不匹配处。

追问

  • 不处理背压的后果?答:内存持续上涨,最终 OOM 或延迟恶化。
  • 背压怎么产生?答:下游写入/消费慢于上游生产,缓冲队列持续增长,流通过暂停与返回 false 反馈上游。

04.2.2.3-007 highWaterMark 如何影响缓冲?

一句话结论

highWaterMark 是内部缓冲阈值(字节或对象数),超过后 write 返回 false 触发背压;它不是总数据上限,只是暂停判断点。

概念解释

阈值决定缓冲弹性空间。调大吞吐更平滑但内存占用高;调小背压更敏感、暂停更频繁。对象模式下单位是对象个数。

原理流程

  1. 数据进入内部缓冲。
  2. 累计量达到阈值。
  3. write 返回 false,等待 drain 排空。

代码或图示

const ws = fs.createWriteStream('out', { highWaterMark: 64 * 1024 });

常见误区

  • highWaterMark 是流能写的最大数据量:超过阈值只是暂停,不是拒绝。
  • 阈值越大越好:大缓冲换来更高内存峰值。

追问

  • 对象模式阈值单位?答:对象数量而非字节,需在构造选项中开启 objectMode。
  • write 返回 false 意味着什么?答:内部缓冲达到 highWaterMark,应等待 drain 事件再继续写。

04.2.2.3-008 pipe 与 pipeline 有什么区别?

一句话结论

pipe 连接流但不自动处理错误与清理;pipeline 管理全链路错误传播、自动销毁流并在结束/失败时清理资源,生产环境应优先使用。

概念解释

手动 pipe 中任一中间流出错,上游与下游可能残留未关闭句柄。pipeline 把多流组成受管管道,错误时统一销毁并回调/返回 Promise。

原理流程

  1. pipeline 串联源、转换、目标。
  2. 任一流错误沿管道传播。
  3. 完成或失败后销毁所有流,释放资源。

代码或图示

const { pipeline } = require('stream/promises');
await pipeline(rs, gzip, ws);

常见误区

  • pipe 出错也会自动清理:它不保证错误时销毁上下游。
  • pipeline 只用于文件:网络、压缩、加密管道同样适用。

追问

  • 旧回调版 pipeline?答:stream.pipeline(streams, callback),Promise 版在 stream/promises。
  • pipe 有什么缺陷?答:错误不自动清理上下游、错误需逐流监听;pipeline 统一汇聚错误并在结束或出错时销毁所有流。

04.2.2.3-009 流的错误为什么必须显式监听?

一句话结论

流未监听 'error' 事件时,错误会作为异常抛出导致进程崩溃;任何使用中的流都要挂 error 处理器并在失败后销毁清理。

概念解释

error 是流的特殊事件,默认行为是抛出。网络中断、磁盘满、转换失败都会触发错误事件,不监听等于裸奔。

原理流程

  1. 流内部失败产生错误。
  2. 触发 error 事件。
  3. 无监听则抛出;有监听则进入错误处理并销毁流。

代码或图示

rs.on('error', (err) => { /* 记录并清理 */ });

常见误区

  • 用外层 try/catch 捕获流错误:错误经事件通道,不在同步栈上。
  • 只监听源流错误:管道中每个流都可能失败。

追问

  • pipeline 如何兜底?答:错误统一汇聚到 pipeline 的回调/Promise,避免逐流挂监听。
  • 未监听 error 会怎样?答:流抛出未捕获错误导致进程崩溃;必须为每个可能失败的流挂 error 监听。

04.2.2.3-010 大文件处理为什么用流而不是 readFile?

一句话结论

readFile 把整文件读入内存,体积超过可用内存时直接 OOM;流按块读取写出,内存占用与文件大小解耦,还可边读边压缩/传输。

概念解释

大日志、备份、媒体文件体量远超堆内存。流式处理保持固定小块缓冲,配合背压跟随磁盘与下游速度。

原理流程

  1. 创建可读流与目标写流。
  2. pipeline 逐块搬运。
  3. 完成后关闭句柄,内存峰值可控。

代码或图示

await pipeline(
  fs.createReadStream('big.bin'),
  zlib.createGzip(),
  fs.createWriteStream('big.gz'),
);

常见误区

  • 大文件分块 readFile 也安全:一次性读入的做法不受分块缓解。
  • 流处理不会出错:仍需处理错误、中断与磁盘空间检查。

追问

  • 待确认:堆内存上限与缓冲配置随部署环境不同,需按实际核对。
  • readFile 风险是什么?答:一次性读入大文件会把整文件堆进内存,文件越大内存峰值越高,易 OOM。

04.2.2.3-011 Buffer 拼接为什么推荐 Buffer.concat?

一句话结论

多个 Buffer 直接拼接要手动计算总长并分配新 Buffer;Buffer.concat(list, totalLength) 一次性分配并拷贝,处理空列表与长度边界更安全。

概念解释

Buffer 是固定长度字节数组,不能像字符串那样直接相加。手动计算长度易错(漏算、重复分配),concat 封装了分配与拷贝。

原理流程

  1. 收集 chunk 列表。
  2. concat 计算总长度并分配新 Buffer。
  3. 依次拷贝各段,返回拼接结果。

代码或图示

const parts = [Buffer.from('a'), Buffer.from('b')];
const all = Buffer.concat(parts);

常见误区

  • 用 buf1 + buf2:会先转字符串,破坏二进制。
  • 不估总长度反复扩容:多次分配拷贝,效率低。

追问

  • 文本流拼接注意?答:多字节字符可能被 chunk 切断,需按编码在字符边界处理。
  • concat 签名是什么?答:Buffer.concat(list, totalLength?),预给总长度可避免内部再估算与扩容。

04.2.2.3-012 对象模式(objectMode)是什么?

一句话结论

普通流 Buffer/字符串 chunk;开启 objectMode 后流可传递任意 JS 对象,缓冲阈值单位变为对象个数,适合处理记录级数据管道。

概念解释

数据库记录、接口条目不是字节流。对象模式让 Transform 输出结构化对象,下游按对象消费;此时 highWaterMark 语义改为对象数。

原理流程

  1. 构造流时 objectMode: true。
  2. write/read 传递普通对象。
  3. 缓冲按对象计数背压。

代码或图示

new Transform({
  objectMode: true,
  transform(obj, _, cb) { cb(null, normalize(obj)); },
});

常见误区

  • 对象模式下 chunk 仍是 Buffer:它是任意对象。
  • 字节流与对象流可直接对接:需在边界做序列化/转换。

追问

  • 混用注意?答:对象流连接字节写流前要转成 Buffer/字符串。
  • 对象模式怎么开启?答:构造流选项 objectMode: true,chunk 为任意 JS 对象,highWaterMark 按对象计数。

04.2.2.3-013 如何用异步迭代器消费流?

一句话结论

Readable 支持 for await (const chunk of rs),按节奏拉取数据,自动处理结束与错误,比手动监听 data 事件更简洁安全。

概念解释

异步迭代把拉取节奏交给语言层面,不需要在 paused/flowing 间手动切换。循环退出即流结束,错误在迭代中抛出。

原理流程

  1. 迭代器按需从 Readable 取 chunk。
  2. 循环体处理每块。
  3. 数据读完迭代结束;失败抛出错误。

代码或图示

for await (const chunk of rs) {
  process(chunk);
}

常见误区

  • 异步迭代与 data 事件同时使用:两种消费方式混用会打乱节奏。
  • 迭代中不处理错误:错误会中断循环并向上抛出。

追问

  • 待确认:异步迭代 API 细节以当前版本流文档为准。
  • 异步迭代怎么写?答:for await (const chunk of readable) { ... };错误在迭代中抛出,需 try/catch 包裹。

04.2.2.3-014 cork/uncork 用来做什么?

一句话结论

cork() 暂存写入数据到内部缓冲,uncork() 一次性冲刷,合并多次小块写入减少底层系统调用次数。

概念解释

频繁小块 write 产生多次底层写。cork 期间累计缓冲,uncork 时批量输出,适合构造报文、批量日志等多段拼接场景。

原理流程

  1. cork 进入暂存状态。
  2. 多次 write 进入缓冲。
  3. uncork 批量写出,注意必须配对调用。

代码或图示

ws.cork();
ws.write('header');
ws.write(body);
ws.uncork();

常见误区

  • cork 后忘记 uncork:数据滞留在缓冲不输出。
  • 用 cork 替代背压处理:它合并写入,不解决下游慢的问题。

追问

  • 与 highWaterMark 关系?答:cork 合并调用,阈值控制背压暂停,两者职责不同。
  • cork 做什么?答:把多次小写入合并到一次底层写,减少系统调用;用完必须 uncork 刷出缓冲。

04.2.2.3-015 流被销毁时要清理什么?

一句话结论

destroy() 结束流并释放底层句柄、定时器与缓冲;失败路径必须销毁相关流,避免句柄泄漏与悬挂回调。

概念解释

流持有文件描述符、网络连接或定时器。异常退出后不销毁,资源不会自动回收;pipeline 在完成/失败时统一执行销毁。

原理流程

  1. 调用 destroy 或触发错误销毁。
  2. 关闭底层资源,清空缓冲。
  3. 触发 close/error 事件,引用解除。

代码或图示

stream.destroy(err);

常见误区

  • 流报错后让其自行 GC:句柄与连接在销毁前持续占用。
  • 只销毁源流:管道中间与目标流也要清理。

追问

  • 句柄泄漏表现?答:文件描述符/连接数持续上涨,见 04.2.2.4。
  • 怎么销毁流?答:调用 destroy(err?);管道中应让 pipeline 统一销毁上下游,避免残留句柄。

04.2.2.3-016 二进制安全与字符串编码转换要注意什么?

一句话结论

二进制数据必须按 Buffer 传递;只有确定文本编码时才解码为字符串,避免在多字节字符中间截断导致乱码或损坏。

概念解释

UTF-8 字符占 1~4 字节,按 chunk 切分可能切断字符。二进制(图片、压缩、加密)用字符串中转会被编码规则破坏。

原理流程

  1. 判断数据是二进制还是文本。
  2. 二进制全程 Buffer 传递。
  3. 文本在完整字符边界解码,必要时维护解码状态。

代码或图示

const text = buf.toString('utf8');

常见误区

  • 任意 Buffer 都直接 toString:二进制被当文本损坏。
  • 每个 chunk 独立解码拼接:跨 chunk 的多字节字符可能乱码。

追问

  • 流式文本解码?答:使用支持增量解码的解码器维护跨块状态。
  • 增量解码怎么做?答:用 TextDecoder 流式模式维护跨块状态,避免多字节字符在 chunk 边界被切断。

04.2.2.3-017 如何组合多个 Transform 形成处理链?

一句话结论

用 pipeline 或 stream.compose 把读取、多个转换、写入依次串联;每个 Transform 只做单一职责,便于测试与替换。

概念解释

处理链 = 源 → 校验 → 转换 → 压缩/加密 → 目标。分段后可单独调整某一步,错误在链上统一汇聚。

原理流程

  1. 定义各 Transform 职责。
  2. compose/pipeline 串联。
  3. 数据逐段通过,背压沿链反向传导。

代码或图示

const { compose } = require('stream');
const chain = compose(normalize, validate, gzip);

常见误区

  • 一个 Transform 塞全部逻辑:难以定位问题与复用。
  • 忽略链上背压传导:上游跟随最慢的下游节点节奏。

追问

  • compose 与 pipeline 区别?答:compose 组装流链,pipeline 执行并管理错误与销毁。
  • 背压如何传导?答:下游 Transform 慢会通过 writable 侧反馈上游,整条链跟随最慢节点节奏。

04.2.2.3-018 排查流相关内存/卡顿问题看哪些点?

一句话结论

检查是否忽略背压(write 返回 false 未处理)、错误流未销毁导致句柄泄漏、对象模式缓冲堆积,以及是否把整份数据缓存到数组。

概念解释

流问题常表现为内存上涨、事件循环卡顿或句柄耗尽。沿管道逐段看缓冲增长位置与错误事件,区分生产过快还是下游阻塞。

原理流程

  1. 定位内存/句柄增长发生在哪个流节点。
  2. 核对 write 返回值与 drain 处理。
  3. 检查错误销毁路径与中间缓存数组。

代码或图示

缓冲增长节点 → 背压处理 → 错误销毁 → 中间缓存 → 对象模式计数

常见误区

  • 看到内存涨就加堆上限:根因可能是背压缺失导致缓冲堆积。
  • 只看源流健康:下游慢会反向撑大整条链缓冲。

追问

  • 待确认:当前版本流内部状态可观测接口,结合调试工具核对。
  • 先看哪几项?答:各流缓冲长度、write 返回值与 drain 事件、上下游速度差、是否遗漏 error/destroy 处理。
  • 待确认:当前版本流内部状态可观测接口,结合调试工具核对。