同步多个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)
  })