许诺我的公羊都吃光了

Question

我有一个我正在使用的API的速率限制器，它允许每秒20个请求。所有请求都是基于promise的，一旦有响应，promise将用API数据来解决。

问题是：

我设置了一个promise数组，其中包含58kpromise都在等待响应。所以慢慢地内存增加，直到我运行内存溢出。在我的特定情况下，我不需要将解析的数据传递给我的然后（），这些数据正在消耗我所有的内存。

守则：

  }).then(() => {
    // 2. Crawl for all clanprofiles from these leaderboards
    const promiseArray = []
    for (let i = 0; i < clanTags.length; i++) {
      // Resolved data from getClanProfile() is eating up all my RAM
      const p = backgroundScheduler.getClanProfile(clanTags[i], true)
      promiseArray.push(p)
    }
    return Promise.all(promiseArray)
  }).then(() => {

那么，有没有一种方法可以等待，直到promise数组被解决，而不需要解决的数据？

Answer 1

如果您没有58kpromise、它们关联的异步操作和它们的结果数据同时处于活动状态，那么您将使用更少的内存。

相反，你想一次运行X个操作，然后当一个操作完成时，你开始下一个操作，同时不会超过X个，也不会超过X个promise同时使用。

您可以尝试使用适当的值X。值1表示顺序操作，但通常可以通过使用更高的值X来提高整体端到端操作时间。如果所有请求都命中同一主机，则X可能不超过5-10（因为一个给定的主机不能一次真正做很多事情，而要求它做比它一次能做的更多的事情只会让它慢下来）。

如果每个请求都发送到不同的主机，那么您可以使X更高。实验将为峰值内存使用率和总体吞吐量提供最佳值，这在一定程度上取决于您的具体情况。

蓝鸟的promise。map（）有一个并发选项，可以为您实现这一点，但也有许多方法可以同时为飞行中的X编码。

下面是一些其他编码示例，用于管理一次飞行的飞机数量：

对一个每分钟只能处理20个请求的API发出多个请求

如何执行一系列的promise？

由于内存溢出无法完成promise

一次发出1000000个请求100个

如何使我可以在javascript中一次执行10个promise，以防止api调用的速率限制？

如果您不需要已解析的数据，您可以通过如下方式替换它，使其能够更快地进行GCD：

  const p = backgroundScheduler.getClanProfile(clanTags[i], true).then(data => {
      return 0;     // make resolved value just be a simple number
                    // so other data is now eligible for GC
  });
  promiseArray.push(p)    

下面是一个简单的实现，它迭代一个数组，同时执行的请求不超过X个：

// takes an array of items and a function that returns a promise
// runs no more than maxConcurrent requests at once
function mapConcurrent(items, maxConcurrent, fn) {
    let index = 0;
    let inFlightCntr = 0;
    let doneCntr = 0;
    let results = new Array(items.length);
    let stop = false;
    
    return new Promise(function(resolve, reject) {
        
        function runNext() {
            let i = index;
            ++inFlightCntr;
            fn(items[index], index++).then(function(val) {
                ++doneCntr;
                --inFlightCntr;
                results[i] = val;
                run();
            }, function(err) {
                // set flag so we don't launch any more requests
                stop = true;
                reject(err);
            });
        }
        
        function run() {
            // launch as many as we're allowed to
            while (!stop && inFlightCntr < maxConcurrent && index < items.length) {
                runNext();
            }
            // if all are done, then resolve parent promise with results
            if (doneCntr === items.length) {
                resolve(results);
            }
        }
        
        run();
    });
}