同步多个 Promise，同时允许多次重试

Question

我正在尝试构建一个自动重试下载的下载器。基本上，一个任务队列，它重试任务一定次数。我第一次尝试使用Promise.all()，但绕过第一次拒绝失败described here 的“技巧”没有帮助（并且是该​​线程中进一步描述的反模式）

所以我得到了一个版本，它似乎在某种程度上符合我的要求。至少它打印的结果是正确的。但它仍然会抛出几个uncaught exception test X 错误/警告，我不知道该怎么办。

代码：

asd = async () => {

  // Function simulating tasks which might fail.
  function wait(ms, data) {
    return new Promise( (resolve, reject) => setTimeout(() => {
      if (Math.random() > 0.5){
        resolve(data);
      } else {
        reject(data);
      }
    }, ms) );
  }

  let tasks = [];
  const results = [];

  // start the tasks
  for ( let i = 0; i < 20; i++) {
    const prom = wait(100 * i, 'test ' + i);
    tasks.push([i, prom]);
  }

  // collect results and handle retries.
  for ( let tries = 0; tries < 10; tries++){
    failedTasks = [];
    for ( let i = 0; i < tasks.length; i++) {

      const task_idx = tasks[i][0];

      // Wait for the task and check whether they failed or not.
      // Any pointers on how to improve the readability of the next 6 lines appreciated.
      await tasks[i][1].then(result => {
        results.push([task_idx, result])
      }).catch(err => {
        const prom = wait(100 * task_idx, 'test ' + task_idx);
        failedTasks.push([task_idx, prom])
      });
    }

    // Retry the tasks which failed.
    if (failedTasks.length === 0){
      break;
    } else {
      tasks = failedTasks;
    }
    console.log('try ', tries);
  }

  console.log(results);
}

最后，results 数组包含（除非任务失败 10 次）所有结果。但还是uncaught exceptions飞来飞去。

由于并非所有被拒绝的承诺都会导致未捕获的异常，因此我怀疑，首先启动任务并稍后应用 then()/catch() 会导致一些时间问题。

感谢对我的问题的任何改进或更好的解决方案。例如。我的解决方案只允许“分波”重试。如果有人提出更好的连续解决方案，那也将不胜感激。

Answer 1

使用await 和asnyc 可以更清晰地解决这个问题。

您将tasks 的数组（执行时启动给定任务的函数）传递给execute_tasks。该函数将为每个任务调用execute_task，将任务函数传递给它，execute_task 将返回一个 Promise，其中包含任务是否成功的信息。

execute_task 作为一个循环循环，直到异步任务成功或达到最大重试次数。

因为每个任务都有自己的重试循环，您可以避免这些波。每个任务都会在失败时排队等待新的执行。以这种方式使用await 会创建某种协作式多任务处理。并且所有错误都得到了处理，因为任务是在try catch 块中执行的。

function wait(ms, data) {
  return new Promise((resolve, reject) => setTimeout(() => {
    if (Math.random() > 0.5) {
      resolve(data);
    } else {
      reject(new Error());
    }
  }, ms));
}


async function execute_task(task) {
  let result, lastError;
  let i = 0
  
  //loop until result was found or the retry count is larger then 10
  while (!result && i < 10) {
    try {
      result = await task()
    } catch (err) {
      lastError = err
      // maybe sleep/wait before retry
    }
    i++
  }

  if (result) {
    return { success: true, data: result }
  } else {
    return { success: false, err: lastError }
  }
}

async function execute_tasks(taskList) {
  var taskPromises = taskList.map(task => execute_task(task))
 
  // the result could be sorted into failed and not failed task before returning
  return await Promise.all(taskPromises)
}


var taskList = []
for (let i = 0; i < 10; i++) {
  taskList.push(() => {
    return wait(500, {
      foo: i
    })
  })
}

execute_tasks(taskList)
  .then(result => {
    console.dir(result)
  })