批量请求函数

使用 Promise 实现一个异步流量控制的函数, 比如一共 10 个请求, 每个请求的快慢不同, 最多同时 3 个请求发出, 快的一个请求返回后, 就从剩下的 7 个请求里再找一个放进请求池里, 如此循环：

async function asyncFlowControl(requests, maxConcurrent) {
  const requestPool = requests.slice(0, maxConcurrent); // 初始请求池
  const requestQueues = requests.slice(maxConcurrent); // 剩余请求
  const results = []; // 存放结果的数组

  async function run() {
    while (requestPool.length > 0) {
      const currentRequest = requestPool.shift(); // 从请求池中取出一个请求
      await processRequest(currentRequest);
      // 如果还有未处理的请求，将一个新请求加入请求池
      if (requestPool.length < maxConcurrent && requestQueues.length > 0) {
        const newRequest = requestQueues.shift();
        requestPool.push(newRequest);
      }
    }
  }

  async function processRequest(request) {
    // 模拟异步请求
    const result = await fakeAsyncRequest(request);
    results.push(result);
  }

  return run().then(() => results);
}

// 模拟异步请求的函数，返回一个 Promise
function fakeAsyncRequest(request) {
  return new Promise(resolve => {
    const delay = Math.floor(Math.random() * 100); // 模拟不同请求的处理时间
    setTimeout(() => {
      console.log(`请求 ${request} 耗时 ${delay} 完成`);
      resolve(`请求 ${request} 结果`);
    }, 100);
  });
}

// 创建10个请求
const requests = Array.from({ length: 10 }, (_, i) => i + 1);

// 控制最多同时3个请求
asyncFlowControl(requests, 3)
  .then(results => {
    console.log('所有请求已完成');
    console.log(results);
  })
  .catch(error => {
    console.error('发生错误：', error);
  });