Node.js / 系统课时

控制并发任务

控制并发任务

异步任务并不是“越多同时开始越好”。本节用一个可运行示例区分串行、完全并行、允许部分失败和限制并发量四种策略,并用耗时与结果顺序验证它们的差异。

学习目标

  • 能根据任务依赖关系选择串行、并行或限流执行。
  • 掌握 Promise.all 与 Promise.allSettled 的失败语义和结果顺序。
  • 能在不引入第三方库的情况下把并发量限制为固定数字。

先按依赖关系选择执行方式

如果任务 B 必须使用任务 A 的结果,就应串行执行;如果 A、B、C 相互独立,可以并行。以三个耗时分别为 120、80、100 ms 的任务为例,串行理论耗时约为 300 ms,完全并行理论耗时接近最长的 120 ms。

Promise.all 负责“等待一组 Promise”,但它不会限制并发量:把 1000 个网络请求先创建出来再传给 Promise.all,这些请求通常已经开始。真正的限流必须控制“什么时候创建并启动下一项任务”。

串行、完全并行、部分失败与限流并发的执行差异

用一个示例比较四种策略

下面示例适用于 Node.js 20+。mapLimit 只启动 limit 个 worker,每个 worker 完成一项后再领取下一项,因此同时运行的任务数不会超过限制值。

js
const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

async function runTask(name, delay, shouldFail = false) {
  await sleep(delay);
  if (shouldFail) throw new Error(`${name} failed`);
  return `${name}:${delay}`;
}

async function runSerial(tasks) {
  const results = [];
  for (const task of tasks) {
    results.push(await runTask(...task));
  }
  return results;
}

async function mapLimit(items, limit, worker) {
  const results = new Array(items.length);
  let nextIndex = 0;

  async function runWorker() {
    while (true) {
      const index = nextIndex++;
      if (index >= items.length) return;
      results[index] = await worker(items[index], index);
    }
  }

  const workerCount = Math.min(limit, items.length);
  await Promise.all(Array.from({ length: workerCount }, runWorker));
  return results;
}

async function main() {
  const tasks = [
    ['A', 120],
    ['B', 80],
    ['C', 100],
  ];

  console.time('serial');
  console.log('serial', await runSerial(tasks));
  console.timeEnd('serial');

  console.time('parallel');
  console.log(
    'parallel',
    await Promise.all(tasks.map(([name, delay]) => runTask(name, delay))),
  );
  console.timeEnd('parallel');

  const settled = await Promise.allSettled([
    runTask('ok', 50),
    runTask('bad', 40, true),
  ]);
  console.log('settled', settled.map((item) => item.status));

  console.log(
    'limit-2',
    await mapLimit(tasks, 2, ([name, delay]) => runTask(name, delay)),
  );
}

main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});

预期输出(<TIME> 为实际耗时,不同机器会有少量波动):

text
serial [ 'A:120', 'B:80', 'C:100' ]
serial: <TIME>ms
parallel [ 'A:120', 'B:80', 'C:100' ]
parallel: <TIME>ms
settled [ 'fulfilled', 'rejected' ]
limit-2 [ 'A:120', 'B:80', 'C:100' ]

串行阶段的 <TIME> 通常接近 300 ms;完全并行接近 120 ms;并发限制为 2 时约为 180 ms。注意 B 虽然先完成,Promise.all 和 mapLimit 的结果仍按输入顺序返回。

失败时决定“立即中止”还是“收集全部结果”

Promise.all 只要有一个 Promise 拒绝,返回的 Promise 就会拒绝,因此适合“任意一步失败就不能继续使用整组结果”的任务,例如同时读取三份启动配置。已经开始的其他任务不会自动取消,若需要取消网络请求,应额外使用支持取消的 API,例如 fetch 配合 AbortController。

Promise.allSettled 会等待全部任务结束,并返回 fulfilled 或 rejected 状态。批量发通知、批量处理文件这类“部分失败也要知道其他项结果”的任务更适合它。检查结果时不要只数成功项,还要把 reason 记录到重试队列。

并发上限从资源瓶颈反推

并发量不要凭感觉设成 50 或 100。若下游接口限制每秒 10 次请求,而单次平均耗时约 200 ms,可以先从并发 2 开始,因为 2 个并发理论上每秒约完成 10 次;若任务是本机 CPU 密集型计算,则 Promise 并发不会带来多核收益,应考虑 worker_threads。

mapLimit 中把 limit 设为 0 会导致没有 worker、任务永远不执行,因此调用前应保证 limit >= 1。生产代码还应记录平均耗时、失败率和 429/503 响应,再逐步调整并发上限,而不是一次性把并发开到最大。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

控制并发任务

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通