在循环内使用异步操作超时

Question

问题：我有一个要删除的用户列表。不仅用户本人被删除，而且与他相关的大量数据也被删除。一些涉及删除用户信息的表包含数百万条记录。 所有内部进程在删除时都是异步启动的。如果删除一个用户时没有问题，并且后台所有进程都成功（即客户端不期望响应），那么如果您运行其中几个，这会占用所有服务器资源，这只要网站被移除，自然会对网站的工作产生负面影响。

for (let i = 0; i < users.length; i++) {
    const user = users[i];
    await this.removeInstance(user, removedBy);
}

this.removeInstance 包含许多其他异步操作。

我想要的：每隔 3 分钟启动一个异步操作 this.removeInstance。 数据删除的速度对我来说并不重要，但根据我的观察，1-2 分钟就足以“完全完成”一个用户。

注意： this.removeInstance 返回已删除的用户，但我不能使用它，因为已经有十几个进程在后台运行以清除他的信息。

感谢您的帮助！

Answer 1

您可以创建一个将异步任务完成延迟到最低限度的包装函数：

const wait = ms =>
  new Promise(resolve => setTimeout(resolve, ms));

const delayCompletion = minTime => task =>
  Promise.allSettled([task(), wait(minTime)])
    .then(([result]) => result.status === "fulfilled"  
      ? result.value 
      : Promise.reject(result.reason)
    );

例子：

const wait = ms =>
  new Promise(resolve => setTimeout(resolve, ms));

const delayCompletion = minTime => task =>
  Promise.allSettled([task(), wait(minTime)])
    .then(([result]) => result.status === "fulfilled"  
      ? result.value 
      : Promise.reject(result.reason)
    );
      

//showcase:

async function main() {
  console.log("-- start loop --");
  for(let i = 0; i < 3; i++) {
    console.log(`start iteration ${i}`);
    
    const delayAtLeastTwoSeconds = delayCompletion(2000);
    const oneSecondtask = () => wait(1000);
    
    await delayAtLeastTwoSeconds(oneSecondtask);
    
    console.log(`finish iteration ${i}`);
  }
  console.log("-- finish loop --");
}

main();

Promise.allSettled() 一直等到所有的 Promise 都不再挂起。我们给它一个异步任务，它添加另一个以最小延迟，所以如果task 提前完成，那么它仍然必须等到延迟计时器完成。相反，如果延迟计时器首先结束，但task 尚未结束，则仍会等待。

Promise.allSettled 解析为一组承诺，其中每个承诺的状态为"fulfilled" 或"rejected"。我们只对数组的第一项感兴趣，因为它是task - 第二项是延迟。如果成功 或 以原始拒绝原因拒绝，我们只返回它的值，如果不是。这样delayCompletion 仍然保留与原始承诺相同的语义，并且任何使用原始承诺的代码都可以透明地使用来自delayCompletion 的承诺。

在某些方面，这与 Promise.race() 相反，它解析为首先解析的承诺。相反，我们等待最后一个，但我们确实有一个固定的返回值。

使用这个辅助函数，您的代码可以这样转换：

const safeDelay = delayCompletion(3 * 60 * 1000); //3 minutes

for (let i = 0; i < users.length; i++) {
    const user = users[i];
    await safeDelay(() => this.removeInstance(user, removedBy));
}

Answer 2

您好，您可以伪造一个睡眠功能并使用它

function sleep(time = 0){
  return new Promise(resolve=>{
    setTimeout(()=>{
      resolve()
    },time)
  })
}

for (let i = 0; i < users.length; i++) {
    const user = users[i];
    await this.removeInstance(user, removedBy);
    await sleep(1000*60*3)
}

Answer 3

很抱歉打扰您，但已找到解决方案。 How do I add a delay in a JavaScript loop?

决赛：

public async removeBatchUsers(usersEmailsList: string[], removedBy: IIdentity) {
    const users: UserSchema[] = await User.find({userEmail: {$in: usersEmailsList}});

    const timer = ms => new Promise(res => setTimeout(res, ms));

    async function load (that) {
        for (let i = 0; i < users.length; i++) {
            const user = users[i];
            await that.removeInstance(user, removedBy);
            await timer(10000);
        }
    }

    load(this);
}

上面使用 Promise.allSettled 的解决方案是最正确和最安全的。经过测试，在我的情况下，我必须另外安装“promise.allsettled”库（23Kb）

Answer 4

如果您不太担心整个过程需要多长时间，您可以使用带有 await 的 for..of 循环在数组上串联运行 this.removeInstance：

for (let user of users) {
  await this.removeInstance(user)
}

这将在开始下一个用户之前等待每个用户被删除 - 然后您可以向客户端返回 http 202 以指示消息已收到并正在处理，也许还实现轮询端点以检查状态的工作。