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)
  })

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

1 个答案: