Javascript 是什么让ES6中的'async/await'语句顺序运行还是并行运行？

我已经通过线程，所以我很清楚的承诺。所有和多个等待

尽管如此，我还是不太清楚以下两种情况

在案例1中，为什么它会顺序执行（需要10秒），而在案例2中它会并行执行（需要4秒）

案例1：

功能承诺等待（时间）{
返回新承诺（（解决、拒绝）=>{
设置超时（（）=>{
决心（正确）；
}，时间）；
});
}
异步函数test1（）{
var t0=performance.now（）
var a=等待承诺等待（1000）
var b=等待承诺等待（2000年）
var c=等待承诺等待（3000）
var d=等待承诺等待（4000）
var t1=performance.now（）
log（“调用doSomething需要“+（t1-t0）+”毫秒。”）；//需要10秒
}
test1（）

在第一种情况下，由于在每次调用

promiseWait

之前都有

等待

，因此要开始执行对

promiseWait

的下一次调用，它需要等到对

promiseWait

的第一次调用完全完成。所以你可以看到顺序执行

在第二种情况下，在开始等待之前，您已经调用了所有promiseWait函数。因此，

promiseWait

已经开始执行，然后您将一个接一个地等待结果

在第一个场景中，对

setTimeout

的下一次调用必须等待第一次

setTimeout

过期。因此，第二、第三和第四个计时器需要等待，直到第一个计时器过期并解析承诺，以便进行调度

---

在秒的情况下，您一个接一个地安排

setTimeout

调用，因此计时器都已排队。然后，你只是在等待计时器过期，然后逐一解决你的承诺。

我认为这是所有4个承诺同时开始的情况。因此，它的setTimeout计时器在后台并行运行

计时器的时间差为1秒，因此如果您在等待之间放置控制台日志，您应该每秒看到一个新的控制台日志

功能承诺等待（时间）{
返回新承诺（（解决、拒绝）=>{
设置超时（（）=>{
决心（正确）；
}，时间）；
});
}
异步函数test2（）{
var t0=performance.now（）
console.log（“将承诺放入que”）；
常数p1=承诺等待（1000）；
const p2=承诺等待（2000年）；
常数p3=承诺等待（3000）；
常数p4=承诺等待（4000）；
console.log（“添加到que中的承诺”）；
常数a=等待p1；
控制台日志（“1”）
常数b=等待p2；
控制台日志（“2”）
常数c=等待p3；
控制台日志（“3”）
常数d=等待p4；
控制台日志（“4”）
var t1=performance.now（）
log（“对doSomething的调用花费了“+（t1-t0）+”毫秒。”）
}
test2（）

进行更深入的研究。。。（灵感来源于菲利普·罗伯茨）

案例1:SetTimeout逐个触发

function promiseWait(time) {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      resolve(new Date().toISOString().split('.')[0].replace('T',' '));
    }, time);
  });
}

async function test1() {
  let timeStamp = new Date();
  var t0 = new Date();
  console.log("t0",t0)

  var a = await promiseWait(1000)
  console.log("a",a)
  var b = await promiseWait(2000)
  console.log("b",b)
  var c = await promiseWait(3000)
  console.log("c",c)
  var d = await promiseWait(4000)
  console.log("d",d)
  
  var t1 = new Date();
  console.log("t1",t1)
  console.log("Call to doSomething took " + (t1 - t0) + " milliseconds."); //takes 10secs

}
test1()

控制台：您可以注意到，每次超时的总和约为10秒

案例2:SetTimeout同时触发

function promiseWait(time) {
    return new Promise((resolve, reject) => {
      setTimeout(() => {
        resolve(new Date().toISOString().split('.')[0].replace('T',' '));
      }, time);
    });
  }
  
  async function test1() {
    let timeStamp = new Date();
    var t0 = new Date();
    console.log("t0",t0)
  
    const p1 = promiseWait(1000);
    const p2 = promiseWait(2000);
    const p3 = promiseWait(3000);
    const p4 = promiseWait(4000);
    
    console.log("p1",p1);
    console.log("p2",p2);
    console.log("p3",p3);
    console.log("p4",p4);

    const a = await p1;
    console.log("a",a);
    const b = await p2;
    console.log("b",b);
    const c = await p3;
    console.log("c",c);
    const d = await p4;
    console.log("d",d);

    var t1 = new Date();
    console.log("t1",t1)
    console.log("Call to doSomething took " + (t1 - t0) + " milliseconds."); //takes 10secs
  
  }
  test1()

控制台：在这里，我们可以注意到计时器一起启动，所以它的结果是~4秒。（最后一个计时器设置为4秒）

---

因为在1）每次等待时，都会在执行下一条语句之前等待承诺兑现-在2）你开始承诺时不会等待前一条语句兑现-所以它们并行运行，因为它实际上。。。在那些等待之间。。。如果你不相信我，就放一些控制台日志进去。。。当每个承诺达成时，他们将间隔1秒输出。AllSetted类似于。all-但从不拒绝，总是已解决-结果显示个人解决/拒绝状态。。。而对于.all，一个拒绝拒绝.allPromises只有在底层支持（如XHR请求）“并行”运行时才“并行”完成（在实践中，这是有限制的，如6个请求/域）。并发！=并行性。如果您知道为什么/如何

Promise.all

工作，那么您应该知道这是如何工作的。这很相似。如果您确实等待Promise.all（[foo（），bar（），baz（）]），那么您首先调用

foo

，

bar

，

baz

（即启动所有承诺），并将其返回值传递给

Promise.all

。这与

var p1=foo（）相同；var p2=bar（）；var p3=baz（）；等待承诺。所有（[p1，p2，p3]）

，这反过来又与

var p1=foo（）相似（不完全相同）；var p2=bar（）；var p3=baz（）；等待p1；等待p2；等待p3。