Javascript 允许IO和计时器在繁重的计算之间执行

我需要在socket服务器上的节点上进行一些CPU密集型计算，但我不想阻塞IO

是否可以使用ES6/ES7特性以良好的方式实现这一点

我的第一次尝试是使用async和await，但似乎是，如果在计时器事件之前调用了大量同步函数，那么只有在执行了所有大量计算调用之后才会调用计时器事件。

这两个版本首先调用所有syncDelays，然后才开始调用计时器事件

---

有没有办法允许在几个cpu繁忙的调用之间调用IO和计时器事件？

我提出的解决方案之一是制作一个WorkManager，它将工作保持在队列中，并在上一个工作结束后将下一个工作添加到javascript eventloop中。这样，其他事件可能会停留在cpu繁重的工作负载部分之间

设t=0
setInterval（异步函数（）{
t=t+1
日志（“计时器：”，t）
}, 1000)
异步函数同步延迟（毫秒）{
log（“syncDelay:，ms，“ms”）
设t1=Date.now（）
while（Date.now（）-t1{
this.first=this.first.next
work.fn（…work.args）
这个是
}, 0)
}
}
让wm=新工作管理器（）
for（设i=0；i<10；i++）{
wm.新建工程（同步延迟，500）
}
console.log（“调用heavyWork后”）

async

/

await

仅适用于异步繁重的工作。在一些真正异步的任务之后，你甚至没有一个承诺可以实现。以及所有这些。

let t = 0
setInterval(async function() {
  t = t + 1
  console.log("timer: ", t)
}, 1000)

async function syncDelay(ms) {
  console.log("syncDelay: ", ms, "ms")
  let t1 = Date.now()
  while (Date.now() - t1 < ms) {}
  return ms
}

async function heavyWork() {
  for (let i = 0; i < 10; i++) {
    await syncDelay(500)
  }
}

heavyWork()
console.log("after calling heavyWork")

setImmediate(() => syncDelay(500))

let t = 0
setInterval(async function() {
  t = t + 1
  console.log("timer: ", t)
}, 1000)

async function syncDelay(ms) {
  console.log("syncDelay: ", ms, "ms")
  let t1 = Date.now()
  while (Date.now() - t1 < ms) {}
  return ms
}

class WorkManager {
  addWork(work) {
    if (this.first === undefined) {
      this.first = work
      this.last = work
      this.runWork()
    } else {
      this.last.next = work
      this.last = work
    }
  }
  newWork(fn, ...args) {
    this.addWork({fn, args})
  }
  runWork() {
    let work = this.first
    if (this.first === undefined) {
      return
    }
    setTimeout(() => {
      this.first = this.first.next
      work.fn(...work.args)
      this.runWork()
    }, 0)
  }
}

let wm = new WorkManager()
for (let i = 0; i < 10; i++) {
  wm.newWork(syncDelay, 500)
}

console.log("after calling heavyWork")