如何处理多个异步任务并行执行

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();

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();

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('所有任务以限制并发数的方式完成。');
// });

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秒后会输出“操作超时”