加速执行多个 async/await 调用

Question

我无法分享我的确切代码 - 但我已尝试在下面说明我的情况：

远程 API 有一个请求最大值。限制为 10 个请求/每秒。我想加快我的代码接近这个限制。目前该代码每秒运行 1-2 个请求。

示例 - 为 100 个不同的人获取 10 小时的数据：

(async function get(...) {
    await getPersonData(for one person);
    if (not all persons' data has been fetched) { get(fetch data for the next person); }
})(...);

async function getPersonData() {
    const personData = await getHistoricalData(...);
    ...
};

async function getHistoricalData(...) {

    // Fetch 10 hours of data ...

    while (as long as all data has not yet been fetch...) {
        const data = await getOneHourOfData(...);
        ...
    }
    return all_20_hours_of_data;
} 

async function getOneHourOfData(...) {
    return await remote.api.getData(get 1 hour of data);
}

上面的示例是我的代码的标准版本 - 我也尝试了两种不同的方法：

• 使用 Promise.all() 并同时获取 5 个人的数据
• 复制/粘贴并同时运行多个版本的 get() 函数（前 4 行代码块）

这两种方法都有效 - 但它们似乎都没有加速任何东西......？？ 我知道是 while 循环阻塞/减慢了整个过程？

Answer 1

您问题中的代码实际上如下所示：

(async function get() {
    try {
        console.time("get");
        console.log(JSON.stringify(await getPersonData()));
        console.timeEnd("get");
    } catch (e) {
        console.error(e);
    }
})();

async function getPersonData() {
    const personData = await getHistoricalData();
    return personData;
};

async function getHistoricalData() {
    const data = [];
    for (let hour = 0; hour < 10; ++hour) {
        data.push(await getOneHourOfData());
    }
    return data;
} 

function delay(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
}

let num = 0;
async function getOneHourOfData() {
    await delay(150);
    return ++num;
}

运行大约需要 1500 毫秒。

这是并行执行 10 个“小时”调用并使用 Promise.all 的相同操作：

(async function get() {
    try {
        console.time("get");
        console.log(JSON.stringify(await getPersonData()));
        console.timeEnd("get");
    } catch (e) {
        console.error(e);
    }
})();

async function getPersonData() {
    const personData = await getHistoricalData();
    return personData;
};

async function getHistoricalData() {
    const promises = [];
    for (let hour = 0; hour < 10; ++hour) {
        promises.push(getOneHourOfData()); // <== No `await`!
    }
    return Promise.all(promises); // <== `await `on this line is optional but
                                  // pointless, this is an `async`
                                  // function, so its promise will be
                                  // resolved to the promise we return
} 

function delay(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
}

let num = 0;
async function getOneHourOfData() {
    await delay(150);
    return ++num;
}

它的运行时间约为 150 毫秒，因为这 10 次历史数据调用是并行发生的。请注意，关键是建立一个 promise 数组（没有 awaiting 它们），然后使用 Promise.all 为整个 promise 数组获取一个 promise。

Answer 2

您可以使用（非常特殊的）信号量来将 API 调用限制为特定速率：

 class TimeSemaphore {
   #times = []; 
   #backlog = Promise.resolve();

   constructor(interval, parallel) {
     this.interval = interval; this.parallel = parallel;
   }

   async aquire(cb) {
     this.#backlog = this.#backlog.then(() => {
      if(this.#times.length >= this.parallel && Date.now() - this.#times[0] < this.interval)
         return new Promise(res => setTimeout(res, this.interval - (Date.now() - this.#times[0]));
     });

    this.#times.push(Date.now());

    await this.#backlog;

    try {
      return await cb();
    } finally {
      this.#times.shift();
    }
  }
 }

这可以用作：

  const apiLimit = new TimeSemaphore(1000, 5);

  async function callAPI() {
    await apiLimit.aquire(async function() {
      await fetch(...);
     });
  }

  callAPI(); // as often as you want

Answer 3

我更喜欢使用Promise.all。

const data = await Promise.all([
  getOneHourOfData(params)
  ... // the same as above but different params x times
])

现在，我对while (as long as all data has not yet been fetch...) { 表达非常好奇。 有没有可能

await new Promise((resolve, reject) => setTimeout(resolve, 1000))

?