多个异步任务并行执行技巧解析

目前golang学习网上已经有很多关于文章的文章了，自己在初次阅读这些文章中，也见识到了很多学习思路；那么本文《多个异步任务并行执行方法解析》，也希望能帮助到大家，如果阅读完后真的对你学习文章有帮助，欢迎动动手指，评论留言并分享~

JavaScript中处理多个异步任务并行执行的核心方法包括：1.使用Promise.all实现“全有或全无”的并发控制，适用于所有数据必须成功获取才能继续执行的场景；2.使用Promise.allSettled确保所有任务无论成功或失败都能完成，便于更细致地处理每个结果；3.通过限制并发数（如实现并发池）避免资源耗尽或服务过载，适合大量任务同时执行的场景；4.采用Promise.race实现竞速机制，常用于设置超时控制；5.结合依赖关系和重试机制提升健壮性，例如链式Promise满足任务依赖、指数退避策略实现智能重试。这些策略可根据实际业务需求灵活选择与组合，以达到高效且稳定的异步处理效果。

处理多个异步任务并行执行，核心在于如何高效地启动它们，并在合适的时候收集结果，同时不阻塞主程序的运行。这通常涉及到并发控制和结果聚合，目的是提升整体的执行效率和用户体验。

在实际操作中，我们遇到需要同时处理多个异步任务的场景实在太多了。比如，一个页面需要从多个API端点获取数据，或者后台服务要同时处理一批数据转换任务。我的经验是，直接将这些任务一股脑地扔出去，然后等待它们全部或部分完成，是提升效率的关键。

在JavaScript中，如何优雅地管理大量并发请求？

谈到JavaScript里的异步任务并行，Promise.all无疑是我的首选。它就像一个协调员，你把所有需要并发执行的Promise都交给它，它会等到所有Promise都成功解决（fulfilled）后，才返回一个包含所有结果的数组。这种“全有或全无”的策略在很多情况下都非常实用，比如你确定所有数据都必须成功获取才能进行下一步操作。

async function fetchMultipleData() {
  try {
    const [userData, productData, orderData] = await Promise.all([
      fetch('/api/user').then(res => res.json()),
      fetch('/api/products').then(res => res.json()),
      fetch('/api/orders').then(res => res.json())
    ]);
    console.log('所有数据都已获取:', { userData, productData, orderData });
  } catch (error) {
    console.error('至少有一个请求失败:', error);
    // 这里可以处理任何一个Promise失败的情况
  }
}
fetchMultipleData();

但生活总不是那么完美，如果其中一个Promise失败了，Promise.all会立即拒绝（reject），并抛出第一个拒绝的原因，而不管其他Promise是否已经成功。这在某些场景下可能不是我们想要的。

这时候，Promise.allSettled就显得非常人性化了。它不会因为某个Promise的失败而中断，而是会等待所有Promise都“落定”（settled），无论是成功解决还是失败拒绝。最后它会返回一个数组，每个元素都描述了对应Promise的最终状态（status为'fulfilled'或'rejected'）和值（value）或原因（reason）。这让我能更细致地处理每个任务的结果，即便有失败的，也能继续处理成功的那些。

async function fetchWithSettledStatus() {
  const results = await Promise.allSettled([
    fetch('/api/user').then(res => res.json()),
    fetch('/api/products').then(res => res.json()),
    Promise.reject(new Error('模拟订单API失败')) // 模拟一个失败的请求
  ]);

  results.forEach((result, index) => {
    if (result.status === 'fulfilled') {
      console.log(`第${index + 1}个请求成功:`, result.value);
    } else {
      console.error(`第${index + 1}个请求失败:`, result.reason);
    }
  });
}
fetchWithSettledStatus();

选择哪个，真的取决于你的业务逻辑。如果某个关键数据缺失会导致整个功能不可用，那Promise.all的即时失败就很有用；如果部分数据缺失不影响整体，只是需要标记出来，Promise.allSettled则提供了更大的灵活性。

当并发任务数量巨大时，如何避免资源耗尽或服务过载？

我曾经遇到过一个情况，需要从一个列表里下载几千张图片。如果直接用Promise.all把几千个下载请求一股脑地扔出去，浏览器会直接卡死，或者服务器因为瞬间涌入大量请求而拒绝服务。这就是典型的资源耗尽或服务过载问题。

解决这个问题的核心思想是“限制并发数”。我们不能同时发起所有请求，而是要控制在某个可接受的上限内，比如每次只允许10个请求同时进行。当一个请求完成时，再从队列中取出下一个请求来执行。

这通常可以通过实现一个简单的并发池或者利用一些库来实现。一个基本的思路是维护一个“正在进行中”的任务计数器。

async function limitedConcurrency(tasks, limit) {
  const results = [];
  const runningPromises = [];
  let index = 0;

  return new Promise(resolve => {
    function runNext() {
      if (index < tasks.length) {
        const task = tasks[index++];
        const promise = task(); // 执行任务，它应该返回一个Promise
        runningPromises.push(promise);

        promise.finally(() => {
          // 无论成功或失败，都从运行队列中移除
          const idx = runningPromises.indexOf(promise);
          if (idx > -1) {
            runningPromises.splice(idx, 1);
          }
          runNext(); // 尝试运行下一个任务
        });

        // 如果当前运行的任务数还没达到上限，继续启动下一个
        if (runningPromises.length < limit && index < tasks.length) {
          runNext();
        }
      } else if (runningPromises.length === 0) {
        // 所有任务都已启动，并且所有正在运行的任务都已完成
        // 这里需要更复杂的逻辑来收集所有结果，通常会用Promise.all(allInitialPromises)
        // 但为了简化，这里只关注并发控制
        resolve(results); // 实际中，这里会等待所有Promise都resolve/reject并收集结果
      }
    }

    // 初始启动，填满并发池
    for (let i = 0; i < limit && i < tasks.length; i++) {
      runNext();
    }
    // 如果任务列表为空，直接解决
    if (tasks.length === 0) {
      resolve([]);
    }
  });
}

// 示例用法：模拟100个异步任务，并发限制为5
const mockTasks = Array.from({ length: 100 }, (_, i) => () => {
  return new Promise(resolve => {
    const delay = Math.random() * 2000; // 模拟1秒内的随机延迟
    setTimeout(() => {
      console.log(`任务 ${i + 1} 完成，耗时 ${delay.toFixed(0)}ms`);
      resolve(`结果 ${i + 1}`);
    }, delay);
  });
});

// limitedConcurrency(mockTasks, 5).then(allResults => {
//   console.log('所有任务以限制并发数的方式完成。');
// });

上面的代码只是一个概念性的框架，实际生产环境中会有更完善的库（如p-limit或async-pool）来处理这些细节，包括结果收集和错误处理。但核心思想就是这样：不让所有任务同时涌入，而是通过一个“闸门”来控制流量。

除了等待所有任务完成，还有哪些高级的并发控制策略？

除了常见的Promise.all和并发限制，我在处理异步任务时，还会用到一些更精细的策略。

一个比较有意思的场景是“竞速”：Promise.race。它会等待传入的Promise数组中，第一个完成（无论是成功还是失败）的Promise，并以它的结果作为整个Promise.race的结果。这在实现超时机制时非常有用。比如，我发起一个网络请求，同时启动一个定时器，如果定时器先到，就认为请求超时。

function withTimeout(promise, timeoutMs) {
  const timeout = new Promise((_, reject) =>
    setTimeout(() => reject(new Error('操作超时')), timeoutMs)
  );
  return Promise.race([promise, timeout]);
}

// 示例：一个可能很慢的请求
const slowRequest = new Promise(resolve => setTimeout(() => resolve('数据已获取'), 3000));

withTimeout(slowRequest, 1000)
  .then(data => console.log('请求成功:', data))
  .catch(error => console.error('请求失败:', error.message)); // 1秒后会输出“操作超时”

此外，任务的依赖关系和重试机制也是高级并发控制中不可忽视的。有时候，一个任务的启动需要依赖另一个任务的结果，但它们又都是更大并行流的一部分。这种情况下，我通常会在Promise.all内部构建链式Promise，确保依赖关系得到满足。

至于重试，当异步任务（特别是网络请求）因为瞬时错误而失败时，直接放弃往往不是最佳选择。我会考虑实现一个带指数退避（exponential backoff）的重试逻辑。这意味着每次重试的间隔时间会逐渐增长，给服务一个恢复的机会，同时避免频繁重试造成更大的压力。这通常会结合递归函数和setTimeout来实现，或者使用一些成熟的重试库。

这些策略的引入，让我在面对复杂的异步场景时，能够更从容、更健壮地构建我的应用程序。毕竟，代码的健壮性在很多时候比极致的性能更重要。

今天关于《多个异步任务并行执行技巧解析》的内容就介绍到这里了，是不是学起来一目了然！想要了解更多关于的内容请关注golang学习网公众号！