JavaScript异步编程中如何有效管理多个Promise的并发与错误处理？JavaScript异步编程中如何有效管理

JavaScript异步编程中如何有效管理多个Promise的并发与错误处理？

问题背景

在现代Web开发中，经常需要并发请求多个API或执行多个异步任务（如上传文件、批量获取数据等）。如果直接使用Promise.all()，其中一个失败会导致整个批量操作失败，用户体验差。如何合理控制并发数量、捕获每个任务的错误并保证其他任务继续执行，是常见痛点。

解决步骤

步骤1: 使用 `Promise.allSettled()` 替代 `Promise.all()`

当需要并行执行多个Promise且希望无论成功或失败都等待所有完成时，使用 allSettled，避免单个失败中断整体流程。

const promises = [
  fetch('/api/user'),
  fetch('/api/orders'),
  fetch('/api/settings'),
  Promise.reject('模拟一个请求失败')
];

Promise.allSettled(promises)
  .then(results => {
    results.forEach((result, index) => {
      if (result.status === 'fulfilled') {
        console.log(`请求 ${index} 成功:`, result.value);
      } else {
        console.warn(`请求 ${index} 失败:`, result.reason);
      }
    });
  });

预期结果：即使某个请求失败，其余请求仍会继续执行并返回结果，便于逐个处理成功/失败状态。

步骤2: 控制并发数量防止资源耗尽

使用“Promise池”模式限制同时运行的异步任务数（例如最多3个并发），适用于处理大量异步任务（如100个文件上传）。

async function asyncPool(poolLimit, array, iteratorFn) {
  const ret = [];
  const executing = [];

  for (const item of array) {
    const p = Promise.resolve().then(() => iteratorFn(item));
    ret.push(p);

    if (poolLimit <= array.length) {
      const e = p.finally(() => {
        executing.splice(executing.indexOf(e), 1);
      });
      executing.push(e);

      if (executing.length >= poolLimit) {
        await Promise.race(executing);
      }
    }
  }

  return Promise.allSettled(ret);
}

// 示例：并发上传最多3个文件
const files = ['file1.txt', 'file2.txt', 'file3.txt', 'file4.txt'];
asyncPool(3, files, async (file) => {
  console.log(`开始上传: ${file}`);
  await new Promise(resolve => setTimeout(resolve, 1000)); // 模拟上传
  if (file === 'file3.txt') throw new Error('上传失败');
  console.log(`上传完成: ${file}`);
}).then(results => {
  results.forEach((result, i) => {
    if (result.status === 'rejected') {
      console.error(`文件 ${files[i]} 上传失败:`, result.reason);
    }
  });
});

预期结果：最多3个任务并发执行，内存和网络压力可控，失败不影响其他任务。

步骤3: 对每个Promise单独捕获错误（fail-fast但隔离错误）

如果仍想用 Promise.all()，但不想因一个失败而中断全部，需提前在每个Promise内部.catch()错误。

const urls = ['/api/a', '/api/b', '/api/c'];

const safePromises = urls.map(url => 
  fetch(url).catch(err => ({
    error: true,
    message: err.message,
    url
  }))
);

Promise.all(safePromises).then(results => {
  results.forEach(result => {
    if (result.error) {
      console.warn('请求失败:', result);
    } else {
      console.log('响应:', result);
    }
  });
});

预期结果：所有请求并发执行，单个网络错误不会导致 Promise.all() 被拒绝，便于统一处理结果。

步骤4: 使用第三方库优化复杂场景（最终方案）

对于更复杂的流程控制（如动态添加任务、优先级调度），推荐使用成熟库如 p-limit。

npm install p-limit

import pLimit from 'p-limit';

const limit = pLimit(2); // 最大并发2

const input = [
  () => fetch('/api/1').then(r => r.text()),
  () => fetch('/api/2').then(r => r.json()),
  () => Promise.reject(new Error('超时'))
];

const promises = input.map(fn => 
  limit(() => fn().catch(err => ({ isError: true, message: err.message })))
);

Promise.allSettled(promises).then(results => {
  console.log('所有任务完成:', results);
});

预期结果：简洁实现并发控制 + 错误隔离，适合生产环境大规模异步任务管理。

常见原因

原因1: 使用 Promise.all() 未处理个别失败，导致整个批处理崩溃
原因2: 并发过多导致浏览器连接池耗尽或服务器限流
原因3: 未对每个异步操作做独立错误捕获，错误溯源困难
原因4: 在循环中直接 await Promise 导致串行执行，性能低下

预防措施

默认使用 Promise.allSettled() 处理批量异步任务，确保健壮性
设置合理的并发上限（建议2~5之间），尤其在移动设备或弱网环境下
每个异步操作包裹 try-catch 或 .catch()，避免错误冒泡中断主流程
封装通用异步池工具函数，在项目中复用（如 asyncPool）
添加超时机制：对每个Promise设置最大等待时间，防止单个任务卡死

注意事项

Promise.all() 只要有一个 reject 就会立即中断，不适合不可靠环境
Promise.allSettled() 兼容性较好（IE除外），现代项目可放心使用
控制并发时避免使用 Promise.race() 不当造成“饥饿”问题，应配合队列管理
在 Node.js 环境中尤其注意文件句柄、数据库连接等资源限制，控制并发至关重要

JavaScript异步编程中如何有效管理多个Promise的并发与错误处理？