优化大量网络请求：分批处理、并发控制与超时策略

const retry = async (requests: API.CarFailedRequest[]) => {
  setIsLoading(true);
  const res = await Promise.all(
    requests.map(async request => {
      try {
        await service.retryFailedRequest(request);
        return { status: true, request };
      } catch (e) {
        return { status: false, request };
      }
    })
  );
  setIsLoading(false);
  return res;
};

// 错误的 Bluebird.map 使用方式
const retry = async (requests: API.CarFailedRequest[]) => {
  setIsLoading(true);
  const promises = requests.map(async request => {
    try {
      await service.retryFailedRequest(request);
      return true;
    } catch (e) {
      return false;
    }
  });

  await BlueBirdPromise.map(
    promises, // 注意：这里传入的是一个已启动的Promise数组
    async promise => {
      try {
        await promise;
      } catch (err) {
        console.log(err);
      }
    },
    { concurrency: 10 }
  );
  setIsLoading(false);
};

// 错误的 manual chunking 方式
const processPromisesWithDelay = async (promises: any[], delay: number, split: number) => {
  const chunks = [];
  for (let i = 0; i < promises.length; i += split) {
    chunks.push(promises.slice(i, i + split));
  }

  for (const chunk of chunks) {
    await Promise.all(chunk.map((promise: () => any) => promise())); // 问题在这里：promise() 意味着立即执行
    await new Promise((resolve) => setTimeout(resolve, delay * 1000));
  }
};

const retry = async (requests: API.CarFailedRequest[]) => {
  setIsLoading(true);
  const promises = requests.map(async request => {
    await service.retryFailedRequest(request); // 再次：所有请求在这里就启动了
  });
  await processPromisesWithDelay(promises, 5, 5); // 传入的是已启动的Promise数组
  setIsLoading(false);
};

import BlueBirdPromise from 'bluebird'; // 确保已安装 bluebird

const retry = async (requests: API.CarFailedRequest[]) => {
  setIsLoading(true);

  await BlueBirdPromise.map(
    requests, // 直接传入原始的请求数据数组
    async request => { // 在这里，当 Bluebird.map 允许时，才启动请求
      try {
        await service.retryFailedRequest(request);
        // 可以根据需要返回状态或数据
        return { status: true, request };
      } catch (err) {
        console.error("请求失败:", request, err);
        // 返回失败状态，或者根据错误类型进行重试
        return { status: false, request, error: err };
      }
    },
    { concurrency: 10 } // 同时只允许 10 个请求处于活跃状态
  );

  setIsLoading(false);
  // 返回处理结果，Bluebird.map 默认会返回一个包含所有迭代器返回值的数组
  // 例如：const results = await BlueBirdPromise.map(...)
  // return results;
};

/**
 * 按批次处理异步任务，并在批次之间添加延迟。
 * @param taskFns 数组，每个元素是一个返回 Promise 的函数。
 * @param chunkSize 每批处理的任务数量。
 * @param delayMs 每批次之间的延迟时间（毫秒）。
 * @returns 所有任务完成后的结果数组。
 */
const processTasksInChunksWithDelay = async <T>(
  taskFns: (() => Promise<T>)[],
  chunkSize: number,
  delayMs: number
): Promise<T[]> => {
  const results: T[] = [];
  for (let i = 0; i < taskFns.length; i += chunkSize) {
    const chunkFns = taskFns.slice(i, i + chunkSize);
    // 在这里才调用函数，启动 Promise
    const chunkPromises = chunkFns.map(fn => fn());
    const chunkResults = await Promise.all(chunkPromises);
    results.push(...chunkResults);

    // 如果还有后续批次，则进行延迟
    if (i + chunkSize < taskFns.length) {
      await new Promise(resolve => setTimeout(resolve, delayMs));
    }
  }
  return results;
};

const retryWithManualChunks = async (requests: API.CarFailedRequest[]) => {
  setIsLoading(true);

  // 将每个请求封装成一个返回 Promise 的函数
  const requestTaskFns = requests.map(request => async () => {
    try {
      await service.retryFailedRequest(request);
      return { status: true, request };
    } catch (e) {
      console.error("请求失败:", request, e);
      return { status: false, request, error: e };
    }
  });

  // 调用分批处理函数，每5个请求一批，每批之间延迟5秒
  const allResults = await processTasksInChunksWithDelay(requestTaskFns, 5, 5000);

  setIsLoading(false);
  return allResults;
};