Promise练习四（并发请求，最大阈值）

背景

Promise.all可以将多个Promise实例包装成一个新的Promise实例。同时，成功和失败的返回值是不同的，成功的时候返回的是一个结果数组，而失败的时候则返回最先被reject失败状态的值（第一次失败就返回了，而不等待后续promise的状态）。

现在想象这样一个场景：如果你的promises 数组中每个对象都是http请求，在瞬间发出几十万http请求（tcp连接数不足可能造成等待），或者堆积了无数调用栈导致内存溢出。这时，就需要考虑对Promise.all做并发限制。

Promise.all并发限制指的是，每个时刻并发执行的promise数量是固定的，最终的执行结果还是保持与原来的Promise.all一致。

实现

原理：由于Promise的函数参数是立即执行的，而非调用Promise.all才执行。因此我们实际是通过并发控制方法来生成promises数组，进而实现限制最大并发请求数量。

const times = [1000, 3000, 4000, 2000, 5000]
const timeOut = (time) => {
  return new Promise((resolve) => {
    setTimeout(() => resolve(time), time);
  });
}
/**
 *
 * @param {Number} poolLimit 最大并发数
 * @param {Array} array 需处理的数组
 * @param {Function} iteratorFn Promise实例
 */
function asyncPool(poolLimit, array, iteratorFn) {
  let i = 0;
  // 用于存储所有Promise实例
  const ret = [];
  // 用于存储正在执行的Promise实例
  const executing = [];
  // 每调一次enqueue，初始化一个promise
  const enqueue = function () {
    // 边界处理
    if (i >= array.length) {
      return Promise.resolve();
    }

    // 生成Promise实例
    const item = array[i++];
    const p = Promise.resolve().then(() => iteratorFn(item, array));

    // 放入promises数组
    ret.push(p);

    // promise执行完毕，从executing数组中删除
    const e = p.then(() => executing.splice(executing.indexOf(e), 1));

    // 插入executing数组，表示正在执行的promise
    executing.push(e);

    // 使用Promise.race，每当executing数组中promise数量低于poolLimit，就实例化新的promise并执行
    let r = Promise.resolve();
    if (executing.length >= poolLimit) {
      r = Promise.race(executing);
    }

    // 递归，直到遍历完array
    return r.then(() => enqueue());
  }
  return enqueue().then(() => Promise.all(ret));
}
// 调用方式
asyncPool(2, times, timeOut).then((res) => console.log(res))