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

04.2.2.2 异步流程错误处理与并发控制

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

04.2.2.2-001 回调风格的错误约定是什么?

一句话结论

Node 错误优先回调签名为 (err, result):第一个参数为错误,成功时为 null/undefined,业务结果放后续参数。

概念解释

错误优先约定让调用方先判断 err,避免把成功数据当错误处理。同步抛错与异步回调错误是两条路径,不能互相替代。

原理流程

  1. 异步操作完成进入回调。
  2. 先判断 if (err) 走错误分支。
  3. 无错误再使用 result。

代码或图示

fs.readFile(path, (err, data) => {
  if (err) return handle(err);
  use(data);
});

常见误区

  • 回调里不判 err 直接用 data:错误对象被当成数据处理。
  • 在回调外 try/catch 捕获异步错误:异步错误不走同步栈。

追问

  • 回调地狱怎么改善?答:封装 Promise,用 async/await 组织流程。
  • 回调签名约定是什么?答:(err, data) 形式,err 为 null 表示成功,先判 err 再用 data。

04.2.2.2-002 Promise 链上错误如何传播?

一句话结论

链中任一 Promise reject,沿链向后传播到最近的 .catch;未被捕获的拒绝成为 unhandledRejection。

概念解释

.then 回调内抛错或返回 reject 都会让后续链失败。catch 处理后可继续返回正常值恢复链,也可再次抛出继续向上传播。

原理流程

  1. 上游 reject 或 then 内抛错。
  2. 跳过后续 fulfilled 回调。
  3. 找到最近 catch 处理;无 catch 则未处理。

代码或图示

fetchUser()
  .then(u => u.profile)
  .catch(err => log(err));

常见误区

  • 每个 then 都要单独 catch:链级 catch 可统一兜底。
  • catch 后链已断开:catch 返回正常值后可继续 then 链。

追问

  • catch 里再抛错会怎样?答:错误继续向后续 catch 传播。
  • 链上哪里放 catch?答:在需要兜底的链尾放一个 .catch;中间 then 抛错会跳过后续 then 直达最近 catch。

04.2.2.2-003 async/await 中如何捕获错误?

一句话结论

用 try/catch 包裹 await,捕获拒绝;catch 后可降级返回默认值或重新抛出,未捕获的 await 拒绝向上冒泡。

概念解释

await 暂停函数等待 Promise 决议。拒绝时等价于在当前函数内 throw,由最近的 try/catch 捕获;顶层未捕获则触发未处理拒绝。

原理流程

  1. await 等待 Promise。
  2. reject 时在 catch 块处理。
  3. 处理后返回值或继续抛出。

代码或图示

async function load() {
  try {
    const data = await fetchData();
    return data;
  } catch (err) {
    return fallback();
  }
}

常见误区

  • 对每个 await 都必须套 try:可在调用方统一 catch。
  • 忘记 await 导致 Promise 悬空:未 await 的拒绝可能无人捕获。

追问

  • 并行 await 怎么写?答:先 Promise.all 汇总,再统一 await。
  • 并行任务怎么写?答:先 const p1 = f1(); const p2 = f2(); 再 await Promise.all([p1,p2]),避免串行 await。

04.2.2.2-004 Promise.all / allSettled / race / any 语义区别?

一句话结论

all 全成功才成功、任一失败即失败;allSettled 等全部结束并返回各自状态;race 取最先决议者;any 任一成功即成功,全失败才失败。

概念解释

不同聚合方式对应不同容错策略:强一致用 all,全量收集用 allSettled,竞速用 race,容错取快成功用 any。

原理流程

  1. 传入 Promise 数组。
  2. 按聚合规则等待决议。
  3. 按规则返回结果数组或首个结果/聚合错误。

代码或图示

const [a, b] = await Promise.all([pa, pb]);
const settled = await Promise.allSettled([pa, pb]);

常见误区

  • allSettled 返回成功值数组:它返回 {status, value/reason} 结构需解包。
  • race 只取最快成功:首个失败也会让 race 决议为失败。

追问

  • any 全失败抛什么?答:聚合所有失败原因的 AggregateError(以当前版本为准)。
  • any 与 race 区别?答:race 首个决议即返回(含失败);any 等待首个成功,全失败才抛 AggregateError。

04.2.2.2-005 如何限制并发数?

一句话结论

用固定大小任务队列:最多 N 个任务在途,完成一个补一个;配合 Promise 包装任务,控制同时发起的异步操作数量。

概念解释

一次性 map 发起全部请求会打爆下游、占满内存与连接。并发限制把在途任务数压在阈值内,排队任务等待空位。

原理流程

  1. 任务入队。
  2. 空闲槽位领取任务执行。
  3. 完成后释放槽位并补入下一个,直到队列清空。

代码或图示

async function limit(tasks, n) {
  const results = [];
  const executing = new Set();
  for (const t of tasks) {
    const p = Promise.resolve().then(t).then(r => {
      results.push(r); executing.delete(p);
    });
    executing.add(p);
    if (executing.size >= n) await Promise.race(executing);
  }
  await Promise.all(executing);
  return results;
}

常见误区

  • 用 await 循环逐个执行:那是串行,不是并发限制。
  • 只限制请求数不限制结果缓冲:大量结果堆积同样占内存。

追问

  • 并发数怎么定?答:按下游容量、连接池与压测延迟确定,不是越大越好。
  • 常见实现模式?答:固定池/滑动窗口:维持 N 个在途任务,完成一个再补一个,可用异步队列封装。

04.2.2.2-006 并发与并行有什么区别?

一句话结论

并发是任务交替推进、调度重叠;并行是同一时刻在多个核上真正同时执行。Node 单线程 JS 内主要是并发,多核并行靠多进程/Worker。

概念解释

IO 等待期间切换处理其他任务形成并发;CPU 任务分到多个核才是并行。理解区别才能判断瓶颈是等待还是计算。

原理流程

  1. 并发:单线程在等待点切换任务。
  2. 并行:多线程/多进程在多核同时计算。
  3. 高并发服务以 IO 并发为主。

代码或图示

并发:任务 A 等待 → 切到 B → A 就绪再回 A
并行:A、B 同一时刻分别在不同核执行

常见误区

  • 发起多个 Promise 就是并行计算:JS 主线程仍是交替调度。
  • 并发数等于核数:并发可远大于核数,靠等待重叠。

追问

  • Node 里怎么拿到并行?答:cluster 多进程或 worker_threads 多线程。
  • 并发解决什么?答:在等待 IO 期间交替推进多个任务,提高等待重叠;并行才是多核同时执行计算。

04.2.2.2-007 异步任务如何设置超时?

一句话结论

用 Promise.race 把业务 Promise 与超时 Promise 竞速,超时后抛指定错误;注意业务任务本身不会自动取消,需配合取消信号。

概念解释

race 只决定谁先决议,不会中止后完成的任务。超时后下游停止等待,但底层请求/计算仍在跑,需显式取消释放资源。

原理流程

  1. 包装超时 Promise(setTimeout)。
  2. race 两者。
  3. 超时分支抛错,必要时触发取消。

代码或图示

const withTimeout = (p, ms) => Promise.race([
  p,
  new Promise((_, rej) => setTimeout(() => rej(new Error('timeout')), ms)),
]);

常见误区

  • 超时后任务自动停止:未取消的底层操作继续占用资源。
  • 超时定时器不清理:即使业务先完成,定时器仍挂着直到触发。

追问

  • 可取消请求怎么做?答:AbortController 信号传给 fetch/底层客户端。
  • Promise.race 怎么用?答:Promise.race([task, timeoutPromise]),超时分支记得清理定时器与底层资源。

04.2.2.2-008 重试策略如何设计?

一句话结论

对可恢复错误做有限次数重试,配合指数退避与抖动区分错误类型;不可恢复错误不重试,重试次数与间隔写入配置。

概念解释

立即无限重试会放大故障。退避拉长间隔避免雪崩,抖动避免同步重试撞墙。区分网络抖动、限流、业务错误与参数错误。

原理流程

  1. 分类错误是否可重试。
  2. 失败后按退避间隔等待并重试。
  3. 达到次数上限放弃并上报。

代码或图示

失败 → 可重试? → 退避(指数+抖动) → 重试 ≤ N 次 → 放弃/降级

常见误区

  • 对所有错误都重试:4xx 类参数/权限错误重试无意义。
  • 固定短间隔疯狂重试:加剧下游压力。

追问

  • 退避公式举例?答:delay = min(base * 2^n, max) 加随机抖动;具体参数按业务压测。
  • 哪些错误不该重试?答:参数错误、鉴权失败、资源不存在等确定性失败不重试;仅对超时、连接重置、5xx 等瞬时错误重试。

04.2.2.2-009 未处理的 Promise 拒绝有什么默认行为?

一句话结论

未捕获的 Promise 拒绝触发 unhandledRejection 事件;Node 15 起默认使进程以非零退出(以当前版本文档为准)。

概念解释

悬空 Promise 没有 catch/await 时错误被漏掉。默认策略趋严,避免静默吞错。应在应用入口挂兜底记录并尽快修复根因。

原理流程

  1. Promise reject 且无处理器。
  2. 微任务收尾检查标记为未处理。
  3. 触发事件,按版本默认策略退出或继续。

代码或图示

process.on('unhandledRejection', (reason) => {
  console.error('unhandled', reason);
});

常见误区

  • 未处理拒绝只是警告:新版本默认会导致非零退出。
  • 兜底钩子能替代业务 catch:它是安全网,不是常规处理路径。

追问

  • 调试时如何定位?答:打印 reason 与堆栈,沿 Promise 链找缺失 catch 的位置。
  • 怎么监听未处理拒绝?答:process.on('unhandledRejection', (reason, p) => ...) 记录并告警;不能替代业务 catch。

04.2.2.2-010 异步错误在事件发射器里如何隔离?

一句话结论

EventEmitter 监听器内抛错默认不扩散到 emit 调用方;需要错误处理时监听 'error' 事件,否则未监听会抛出导致进程崩溃。

概念解释

事件回调不在 emit 的同步调用栈上。error 是约定特殊事件,未监听时 Node 抛出异常。其他事件的监听器错误需在内部自行捕获。

原理流程

  1. emit 触发各监听器。
  2. 监听器内抛错不回传 emit 调用方。
  3. error 事件无监听则抛出;业务事件内部 try/catch。

代码或图示

emitter.on('error', (err) => handle(err));

常见误区

  • 用外层 try/catch 包住 emit 捕获监听器错误:栈不互通。
  • 以为所有事件错误都自动上报:只有 error 事件有特殊抛出约定。

追问

  • 流的错误处理?答:必须监听 'error',否则错误会抛出导致崩溃。
  • error 事件特殊在哪?答:监听器抛错且无 'error' 监听时,错误作为未捕获异常抛出;其他事件错误不自动上报。

04.2.2.2-011 批量任务部分失败如何聚合结果?

一句话结论

用 allSettled 收集每项状态,成功项取 value,失败项记录 reason;按业务决定整体成功条件与失败上报粒度。

概念解释

all 遇到首错即中断后续结果收集。需要保留全部结果时,先聚合再分类处理:可降级的失败项走默认值,致命失败项阻断流程。

原理流程

  1. allSettled 等待全部结束。
  2. 遍历结果按 status 分组。
  3. 成功入结果集,失败入错误集并按策略处理。

代码或图示

const res = await Promise.allSettled(list.map(fetchItem));
const ok = res.filter(r => r.status === 'fulfilled').map(r => r.value);

常见误区

  • allSettled 也会在首失败中断:它等待全部结束。
  • 失败项直接丢弃不记录:应保留错误原因便于排查。

追问

  • 部分成功能否返回?答:按业务 SLA 决定,可返回成功集合并标注失败项。
  • allSettled 结果怎么解包?答:每项 {status:'fulfilled', value} 或 {status:'rejected', reason},分别收集成功与失败列表。

04.2.2.2-012 如何用 AbortController 取消异步操作?

一句话结论

创建 AbortController,把 signal 传给支持取消的 API;调用 abort() 触发信号,监听 abort 事件释放底层资源。

概念解释

Promise 本身不能强制中断,取消靠协作式信号:操作方收到信号后停止请求、关闭流或清理定时器。兼容 fetch 与部分原生模块。

原理流程

  1. new AbortController 得到 signal。
  2. 信号传入 API 与监听器。
  3. abort() 通知取消,各响应方清理。

代码或图示

const ctrl = new AbortController();
fetch('/api', { signal: ctrl.signal });
ctrl.abort();

常见误区

  • abort 能杀掉不支持信号的自定义计算:不协作的任务无法被强制中断。
  • 取消后不清理定时器/连接:需在 abort 监听里释放资源。

追问

  • 超时与取消配合?答:超时触发 abort,由信号统一通知各操作停止。
  • 信号怎么传给操作?答:构造 new AbortController(),把 signal 传入 fetch/客户端;abort() 触发信号,监听器释放资源。

04.2.2.2-013 队列积压时怎么做背压与降级?

一句话结论

限制队列长度,超出后按策略拒绝、降级或丢弃低优先级任务;下游恢复后再放量,避免内存与延迟持续膨胀。

概念解释

无界队列在生产变慢时持续堆积,最终内存溢出。背压把负载反馈给上游,降级保证核心路径可用。

原理流程

  1. 队列设上限与在途并发阈值。
  2. 超出时拒绝/降级/排队等待。
  3. 监控队列长度与延迟,动态调整并发。

代码或图示

任务到达 → 队列有空位? → 入队执行
                      └ 满 → 拒绝/降级/阻塞上游

常见误区

  • 只加队列不加上限:积压直接转化为内存泄漏。
  • 降级逻辑绕过错误上报:降级结果需标记并监控。

追问

  • 队列指标看什么?答:长度、在途数、等待时长、拒绝率。
  • 队列上限怎么定?答:按内存与下游容量设最大长度,超出后拒绝或降级并上报,不无限排队。

04.2.2.2-014 顶层模块 await 失败会影响什么?

一句话结论

顶层 await reject 会使模块加载失败,依赖该模块的导入链一起报错;应用启动阶段应捕获初始化错误并优雅退出。

概念解释

顶层 await 把初始化纳入加载图。初始化失败(配置加载、连接建立)应在启动时暴露,而不是让服务带病启动。

原理流程

  1. 模块顶层 await 初始化。
  2. reject 沿加载链传播。
  3. 入口捕获后记录错误、清理资源并退出。

代码或图示

try {
  await init();
} catch (err) {
  console.error(err);
  process.exit(1);
}

常见误区

  • 顶层失败后服务继续跑:未处理初始化错误会让下游状态不完整。
  • 在子模块吞掉初始化错误:问题被掩盖到运行时才暴露。

追问

  • 启动失败清理什么?答:关闭已建立的连接、定时器与监听句柄。
  • 启动失败如何退出?答:捕获初始化错误后清理已建连接、定时器与监听句柄,以非零退出码结束进程。

04.2.2.2-015 如何避免“悬空 Promise”造成漏错?

一句话结论

发起 Promise 要么 await,要么显式 .catch 并记录;不保存引用、不挂处理器的悬空 Promise 是未处理拒绝的主要来源。

概念解释

fire-and-forget 任务容易漏掉失败。规范要求每条异步路径都有错误出口:等待、捕获或上报后再丢弃。

原理流程

  1. 识别未 await 的异步调用。
  2. 补 catch 记录错误或改为 await。
  3. 入口兜底 unhandledRejection。

代码或图示

fireAndForget().catch(err => log(err));

常见误区

  • 后台任务不用管错误:后台失败同样需要记录与告警。
  • 把 catch 留空:吞错比报错更难排查。

追问

  • 静态检查能发现吗?答:lint/类型检查可辅助标记未处理 Promise,仍需人工复核。
  • 什么是悬空 Promise?答:返回 Promise 却未 await、未 catch、未返回给上层,导致拒绝无人处理。

04.2.2.2-016 并发数与下游容量如何匹配?

一句话结论

先测量下游安全并发与单任务耗时,再按 并发 = 目标吞吐 × 单任务耗时 估算,结合连接池上限与压测 p99 延迟收紧。

概念解释

并发过高压垮下游,过低浪费容量。容量匹配要同时考虑下游线程/连接限制、网络 RTT 和本进程资源,不能凭感觉定值。

原理流程

  1. 压测下游在不同并发下的吞吐与错误率。
  2. 按 Little 定律估算所需并发。
  3. 留余量设初始值,线上按指标回调。

代码或图示

并发 ≈ 目标吞吐(请求/秒) × 平均耗时(秒)

常见误区

  • 并发数设成线程/核数:IO 型并发由等待时间决定。
  • 不看下游限制就放大并发:导致下游队列雪崩。

追问

  • 待确认:具体容量阈值需在目标环境压测,不能套用固定数字。
  • 怎么压测取并发值?答:逐步提高并发,观察下游 P99 延迟、错误率与连接占用,取拐点前的安全并发值。

04.2.2.2-017 异步流程中如何保持上下文(请求 id、租户、日志字段)?

一句话结论

通过显式参数传递,或用 AsyncLocalStorage 在异步链路上保存并读取请求级上下文,避免靠模块级全局变量串号。

概念解释

单线程下共享全局变量会被并发请求覆盖。AsyncLocalStorage 在每个异步链路内隔离上下文,跨 await/回调读取同一请求字段。

原理流程

  1. 请求进入时 als.run(store, handler)。
  2. 异步链路内 als.getStore() 读取上下文。
  3. 不同请求链路互不干扰。

代码或图示

const als = new AsyncLocalStorage();
als.run({ requestId }, () => { /* 内部可读取 */ });

常见误区

  • 用模块级对象存当前请求:并发请求互相覆盖。
  • 跨线程/进程自动共享上下文:上下文只在当前异步链路内有效。

追问

  • 待确认:AsyncLocalStorage 在 Worker/跨进程场景的行为,以文档为准。
  • 用什么存异步上下文?答:AsyncLocalStorage 在同一异步链路内存取请求 id、租户等;不能用模块级全局对象。

04.2.2.2-018 排查异步疑难错误的一般步骤是什么?

一句话结论

先复现最小路径,打印完整错误与堆栈,区分同步异常/未处理拒绝/事件错误,再沿异步链路核对处理器是否缺失,最后加日志定位上下文。

概念解释

异步错误最难的是堆栈断裂与处理器缺失。按错误类型分类,比在大段业务代码里盲找高效。

原理流程

  1. 收集错误类型、堆栈与触发条件。
  2. 判断属于回调/Promise/事件哪条路径。
  3. 沿链路补处理器,加请求上下文日志复现。

代码或图示

错误类型分类 → 堆栈与上下文 → 链路处理器核对 → 最小复现 → 修复验证

常见误区

  • 只看错误消息不看堆栈:异步断裂栈需要结合日志定位。
  • 兜底钩子抓到错误就改钩子:根因仍在缺失业务处理器。

追问

  • 如何保留完整异步栈?答:记录错误发生时的上下文与链路日志,必要时用工具追踪 Promise 链。
  • 先收集哪些信息?答:错误类型与 reason、完整堆栈、请求链路日志、触发时序与并发量,再沿 Promise/事件链定位缺失处理器。
  • 如何保留完整异步栈?答:记录错误发生时的上下文与链路日志,必要时用工具追踪 Promise 链。