深入理解 Promise 并行处理：从 Promise.all 到 allSettled

在 JavaScript 异步编程的世界里，Promise 无疑是最重要的里程碑之一。它让异步操作不再是回调地狱的代名词，而是变得更加优雅和可维护。在 Promise 的众多静态方法中，并行处理相关的 API 尤为重要，它们能帮助我们高效地处理多个异步任务。本文将深入探讨 Promise.all()、Promise.race()、Promise.any() 和 Promise.allSettled() 这四个关键方法的特性、使用场景及最佳实践。

Promise.all：全成功才成功的完美主义者

定义与工作原理

根据 MDN 的定义，Promise.all() 方法接受一个 Promise 的可迭代对象（Array、Map、Set 都属于 ES6 的可迭代对象）作为输入，并且只返回一个 Promise 实例。这个返回的 Promise 会在所有输入的 Promise 都成功（fulfilled）时才成功，此时它的 resolve 回调结果是一个数组，按顺序存放着所有输入 Promise 的 resolve 结果。

值得注意的是，Promise.all() 的结果数组顺序始终与输入的可迭代对象顺序一致，而不受各个 Promise 实际完成顺序的影响。这一点在处理需要保持顺序的异步数据时非常重要。

失败处理机制

Promise.all() 有一个严格的"失败快速"机制：只要任何一个输入的 Promise 被拒绝（rejected），Promise.all() 就会立即抛出错误，并且状态会变成 rejected。此时，Promise.all() 返回的 Promise 会被拒绝，catch 回调会执行，拒绝的原因是第一个被抛出的错误。

一个容易被忽视的细节是：即使有一个 Promise 子项被拒绝，其他还没有完成的 Promise 仍然会继续执行，只不过它们的结果不再影响最终状态，因为最终状态已经确定为失败。这是因为 Promise 一旦创建就会开始执行，不受其他 Promise 状态的影响。

代码示例

javascript 复制代码

const promise1 = Promise.resolve(3);
const promise2 = 42;
const promise3 = new Promise((resolve, reject) => {
  setTimeout(resolve, 100, 'foo');
});

Promise.all([promise1, promise2, promise3]).then((values) => {
  console.log(values); // 输出: [3, 42, "foo"]
});

// 失败示例
const promise4 = Promise.reject('error');
Promise.all([promise1, promise4, promise3]).catch((error) => {
  console.log(error); // 输出: 'error'
});

Promise 家族的并行处理方法：四大金刚

除了 Promise.all()，ES6 及后续标准还引入了其他三个并行处理方法，它们各有特点，适用于不同的场景。

1. Promise.race()：谁快听谁的

Promise.race() 方法同样接受一个可迭代的 Promise 对象集合，但它的行为与 Promise.all() 截然不同。它就像一场竞赛，哪个 Promise 最先完成（无论是 fulfilled 还是 rejected），它的结果就决定了 Promise.race() 的最终状态。

应用场景：

设置异步操作的超时时间
实现网络请求的降级策略（优先使用更快的接口）
实时数据更新的抢占式处理

javascript 复制代码

const promise1 = new Promise((resolve, reject) => {
  setTimeout(resolve, 500, 'one');
});

const promise2 = new Promise((resolve, reject) => {
  setTimeout(resolve, 100, 'two');
});

Promise.race([promise1, promise2]).then((value) => {
  console.log(value); // 输出: 'two'，因为 promise2 更快
});

2. Promise.any()：首个成功即成功

Promise.any() 是 ES2021 引入的新方法，它的规则是：只要有一个 Promise 成功（fulfilled），它就立即成功；只有当所有 Promise 都失败（rejected）时，它才会失败，并返回一个包含所有失败原因的 AggregateError 对象。

与 Promise.race() 的区别 ：Promise.race() 关注的是第一个完成的 Promise，而 Promise.any() 关注的是第一个成功的 Promise。

应用场景：

实现服务的故障转移（多个相同服务取第一个成功响应）
优化用户体验（从多个CDN获取资源，取最快可用的）
提高系统可用性（多个数据源，至少有一个可用即可）

javascript 复制代码

const promise1 = Promise.reject('error1');
const promise2 = new Promise((resolve) => setTimeout(resolve, 200, 'success'));
const promise3 = Promise.reject('error3');

Promise.any([promise1, promise2, promise3]).then((value) => {
  console.log(value); // 输出: 'success'，因为 promise2 是第一个成功的
});

3. Promise.allSettled()：全部完成才结束

Promise.allSettled() 也是 ES2020 引入的新方法，它与其他方法最大的区别在于：它会等待所有的 Promise 都 settled（无论是 fulfilled 还是 rejected），然后返回一个包含每个 Promise 结果的数组。数组中的每个元素都是一个对象，包含 status 和 value/reason 属性，清晰地展示了每个异步操作的结果。

应用场景：

批量操作的结果统计（需要知道每个操作的具体结果）
日志收集（即使部分操作失败，也要收集所有日志）
仪表盘数据加载（多个模块数据独立加载，互不影响）

javascript 复制代码

const promise1 = Promise.resolve('success1');
const promise2 = Promise.reject('error2');

Promise.allSettled([promise1, promise2]).then((results) => {
  results.forEach((result) => {
    if (result.status === 'fulfilled') {
      console.log('成功:', result.value);
    } else {
      console.log('失败:', result.reason);
    }
  });
  // 输出:
  // 成功: success1
  // 失败: error2
});

Promise 并行与 async/await 的抉择

在现代 JavaScript 开发中，async/await 语法糖让异步代码看起来更像同步代码，使用起来非常直观。但这并不意味着我们应该完全抛弃 Promise.all() 等并行方法。

async/await 的局限性

async/await 在默认情况下是串行执行的。如果我们像下面这样写代码，每个异步操作都会等待前一个操作完成：

javascript 复制代码

async function serialTasks() {
  const result1 = await task1();
  const result2 = await task2();
  const result3 = await task3();
  return [result1, result2, result3];
}

这种方式在任务之间有依赖关系时很有用，但如果任务之间是独立的，串行执行会导致总耗时等于所有任务的耗时之和，效率低下。

并行处理的优势

当我们需要处理多个独立的异步任务时，使用 Promise.all() 等并行方法可以显著提高效率，因为它们能充分利用 JavaScript 的非阻塞特性，让多个异步操作同时执行。

javascript 复制代码

async function parallelTasks() {
  const [result1, result2, result3] = await Promise.all([
    task1(),
    task2(),
    task3()
  ]);
  return [result1, result2, result3];
}

在这种情况下，总耗时大约等于耗时最长的单个任务的时间，而不是所有任务时间的总和。

最佳实践

如果异步操作之间有依赖关系，优先使用 async/await 的串行方式
如果异步操作之间相互独立且需要全部成功，使用 Promise.all()
如果只需要最快的一个结果（无论成功失败），使用 Promise.race()
如果只需要第一个成功的结果，使用 Promise.any()
如果需要所有操作的结果（无论成功失败），使用 Promise.allSettled()

实战案例：构建高效的并行数据获取系统

场景描述

假设我们需要开发一个新闻聚合应用，需要从多个不同的新闻 API 获取数据，然后整合显示给用户。我们希望达到以下目标：

尽可能快地显示数据给用户
即使某个 API 失败，也不影响整体功能
能够监控每个 API 的响应状态和性能

实现方案

结合我们所学的 Promise 并行处理知识，我们可以设计一个混合方案：

javascript 复制代码

async function fetchNews() {
  // 1. 同时启动所有 API 请求
  const apiCalls = [
    fetchFromApi('https://news-api-1.com/articles'),
    fetchFromApi('https://news-api-2.com/latest'),
    fetchFromApi('https://news-api-3.com/top-stories')
  ];
  
  // 2. 使用 Promise.any() 快速获取首个成功的结果，用于即时显示
  const fastNewsPromise = Promise.any(apiCalls)
    .then(fastNews => {
      console.log('快速显示新闻:', fastNews);
      displayNewsToUser(fastNews);
    })
    .catch(err => {
      console.error('所有 API 都失败了:', err);
    });
  
  // 3. 使用 Promise.allSettled() 收集所有结果，用于后续分析和统计
  const allResults = await Promise.allSettled(apiCalls);
  
  // 4. 处理所有结果，进行性能分析和错误跟踪
  allResults.forEach((result, index) => {
    if (result.status === 'fulfilled') {
      console.log(`API ${index + 1} 成功，数据量: ${result.value.length}`);
      // 合并所有成功的数据用于完整视图
      mergeNewsData(result.value);
    } else {
      console.error(`API ${index + 1} 失败:`, result.reason);
      // 记录错误，用于监控和后续优化
      logApiError(index + 1, result.reason);
    }
  });
  
  // 5. 更新完整视图
  updateCompleteNewsView();
}

这个方案结合了 Promise.any() 和 Promise.allSettled() 的优势，既能快速响应用户，又能全面收集所有数据和状态信息，是一个比较理想的解决方案。

总结与未来展望

Promise 的并行处理方法为 JavaScript 异步编程提供了强大而灵活的工具集。通过掌握 Promise.all()、Promise.race()、Promise.any() 和 Promise.allSettled() 的特性和适用场景，我们可以编写出更高效、更健壮的异步代码。

随着 JavaScript 语言的不断发展，我们可以期待未来会有更多更强大的异步处理工具出现。但无论如何，这些基本的 Promise 并行处理方法都将是我们异步编程的基石。

最后，记住一个简单的原则：没有最好的异步处理方法，只有最适合当前场景的方法。在实际开发中，我们需要根据具体需求，灵活选择和组合不同的异步处理策略，以达到最佳的性能和用户体验。