如何在并行 Javascript 中运行“x”承诺

Question

我有一个函数“promiseFunction”，它返回一个承诺，它会在以后解决。

我需要多次调用此函数，但我只希望一次执行该函数的设定次数。

该函数在我的计算机上调用一些外部单线程 c 代码，如果我一次调用太多此代码的实例，我的系统会崩溃，但如果我一次按顺序调用它 1，它会非常慢，因为只有一个线程我的 cpu 正在做任何工作。

所以我想出了下面的代码，但是它不起作用。它将并行调用前 10 个 Promise，但慢慢地它开始一次调用越来越少的 Promise，直到它一次只调用 1 个 Promise。

var totalNumberOfPromises = // total number times to run promiseFunction;
var promiseCounter = 0; // keep track of which promise call this is 
for(w=0;w<10;w++){ // run 10 promises at a time
  promiseFunction().then(function(resolve) {
    loadNewPromise();
  })
  promiseCounter++;
}

function loadNewPromise(){

  if(promiseCounter<totalNumberOfPromises){
    promiseFunction().then(function(resolve) {  loadNewPromise(); });
  }else{
    alert("Finished");
  }
  promiseCounter++;
}

上面的代码有什么问题会导致这种行为吗？有没有这样做的标准方法？

Answer 1

这是我之前准备的一个函数（我已经用了几年了，就是为了这样的事情

const multiQueue = length => {
    length = (isNaN(length) || length < 1) ? 1 : length;
    const q = Array.from({length}, () => Promise.resolve());
    let index = 0;
    const add = cb => {
        index = (index + 1) % length;
        return (q[index] = q[index].then(() => cb()));
    };
    return add;
};

// demo usage

const q = multiQueue(10);

let inFlight = 0;
let maxInFlight = 0;
const promiseFunction = (i) => {
  	inFlight++;
    maxInFlight = Math.max(inFlight, maxInFlight);
    const obj = {inFlight, maxInFlight, i};
    return new Promise(resolve => {
        setTimeout(() => {
            inFlight--;
            resolve(Object.assign(obj, {t:performance.now()}));
        }, 10 );
    })
};

for (let i = 0; i < 40; i++) {
    q(() => promiseFunction(i)).then(v => console.log(JSON.stringify(v)));
}

可以看到最多有 10 个“inFlight”请求

Answer 2

这样的事情怎么样？如果你构造你的 queue 和 functions 中的 Array 返回一个 Promise 你可以将 splice 分块出来并用 Promise.all 处理每个块。

const fakePromise = (id) => {
  return new Promise((resolve) => {
    setTimeout(() => {
      console.log(`Resolving promise ${id}`)
      resolve(id)
    }, 100)
  })
}

const queue = Array(100).fill().map((_, i) => {
  return () => fakePromise(i)
})

const batchProcessPromises = (promises, batchSize) => {
  if (promises && promises.length) {
    return Promise.all(
      promises.splice(0, batchSize)
        .map(promise => promise())
    )
      .then(() => {
        console.log('Batch complete')
        return batchProcessPromises(promises, batchSize)
      })
  }
  console.log('Batch complete')
  return Promise.resolve()
}

batchProcessPromises(queue, 10)
  .then(() => {
    console.log('Time to get one with my day')
  })

你打算如何构建你的所有承诺？此函数会影响原始队列，因此您需要确保传入batchProcessPromises 的数组不被共享。为了解决这个问题，您可以像这样使用扩展运算符

batchProcessPromises([...queue], 10)
  .then(() => {
    console.log('Time to get one with my day', queue)
  })

在这里提琴https://jsfiddle.net/stwilz/2bpdcxo6/24/