据我所知，在ES7/ES2016中，在代码中放置多个await将类似于用promise链接.then（），这意味着它们将一个接一个地执行，而不是并行执行。例如，我们有以下代码：
await someCall();
await anotherCall();
我是否正确理解只有当someCall（）完成时才会调用另一个otherCall（）？并行调用它们最优雅的方式是什么？
我想在Node中使用它，所以也许有一个异步库的解决方案？
编辑：我对这个问题中提供的解决方案不满意：由于异步生成器中的非并行等待承诺，所以速度变慢，因为它使用生成器，我问的是一个更通用的用例。
当前回答
await Promise.all（[someCall（），anotherCall（）]）；正如已经提到的那样，它将充当线程围栏（在CUDA这样的并行代码中非常常见），因此它将允许其中的所有承诺在不相互阻止的情况下运行，但将阻止执行继续，直到解决所有问题。
另一种值得分享的方法是Node.js异步，如果任务直接与API调用、I/O操作等有限资源的使用相关联，它还允许您轻松控制通常需要的并发量。
// create a queue object with concurrency 2
var q = async.queue(function(task, callback) {
console.log('Hello ' + task.name);
callback();
}, 2);
// assign a callback
q.drain = function() {
console.log('All items have been processed');
};
// add some items to the queue
q.push({name: 'foo'}, function(err) {
console.log('Finished processing foo');
});
q.push({name: 'bar'}, function (err) {
console.log('Finished processing bar');
});
// add some items to the queue (batch-wise)
q.push([{name: 'baz'},{name: 'bay'},{name: 'bax'}], function(err) {
console.log('Finished processing item');
});
// add some items to the front of the queue
q.unshift({name: 'bar'}, function (err) {
console.log('Finished processing bar');
});
Medium文章自动收录（阅读更多）
其他回答
没有Promise.all（）还有另一种方法可以并行执行：
首先，我们有两个功能来打印数字：
function printNumber1() {
return new Promise((resolve,reject) => {
setTimeout(() => {
console.log("Number1 is done");
resolve(10);
},1000);
});
}
function printNumber2() {
return new Promise((resolve,reject) => {
setTimeout(() => {
console.log("Number2 is done");
resolve(20);
},500);
});
}
这是顺序的：
async function oneByOne() {
const number1 = await printNumber1();
const number2 = await printNumber2();
}
//Output: Number1 is done, Number2 is done
这是平行的：
async function inParallel() {
const promise1 = printNumber1();
const promise2 = printNumber2();
const number1 = await promise1;
const number2 = await promise2;
}
//Output: Number2 is done, Number1 is done
我创建了一个助手函数waitAll，也许它可以让它更甜。它目前只在nodejs中工作，在浏览器chrome中不工作。
//const parallel = async (...items) => {
const waitAll = async (...items) => {
//this function does start execution the functions
//the execution has been started before running this code here
//instead it collects of the result of execution of the functions
const temp = [];
for (const item of items) {
//this is not
//temp.push(await item())
//it does wait for the result in series (not in parallel), but
//it doesn't affect the parallel execution of those functions
//because they haven started earlier
temp.push(await item);
}
return temp;
};
//the async functions are executed in parallel before passed
//in the waitAll function
//const finalResult = await waitAll(someResult(), anotherResult());
//const finalResult = await parallel(someResult(), anotherResult());
//or
const [result1, result2] = await waitAll(someResult(), anotherResult());
//const [result1, result2] = await parallel(someResult(), anotherResult());
这可以通过Promise.allSettled（）实现，它类似于Promise.all（），但没有快速失败行为。
async function Promise1() {
throw "Failure!";
}
async function Promise2() {
return "Success!";
}
const [Promise1Result, Promise2Result] = await Promise.allSettled([Promise1(), Promise2()]);
console.log(Promise1Result); // {status: "rejected", reason: "Failure!"}
console.log(Promise2Result); // {status: "fulfilled", value: "Success!"}
注意：这是一个边缘功能，浏览器支持有限，因此我强烈建议为该功能添加polyfill。
await Promise.all（[someCall（），anotherCall（）]）；正如已经提到的那样，它将充当线程围栏（在CUDA这样的并行代码中非常常见），因此它将允许其中的所有承诺在不相互阻止的情况下运行，但将阻止执行继续，直到解决所有问题。
另一种值得分享的方法是Node.js异步，如果任务直接与API调用、I/O操作等有限资源的使用相关联，它还允许您轻松控制通常需要的并发量。
// create a queue object with concurrency 2
var q = async.queue(function(task, callback) {
console.log('Hello ' + task.name);
callback();
}, 2);
// assign a callback
q.drain = function() {
console.log('All items have been processed');
};
// add some items to the queue
q.push({name: 'foo'}, function(err) {
console.log('Finished processing foo');
});
q.push({name: 'bar'}, function (err) {
console.log('Finished processing bar');
});
// add some items to the queue (batch-wise)
q.push([{name: 'baz'},{name: 'bay'},{name: 'bax'}], function(err) {
console.log('Finished processing item');
});
// add some items to the front of the queue
q.unshift({name: 'bar'}, function (err) {
console.log('Finished processing bar');
});
Medium文章自动收录（阅读更多）
TL；博士
对并行函数调用使用Promise.all，当发生错误时，应答行为不正确。
首先，立即执行所有异步调用并获取所有Promise对象。其次，对Promise对象使用await。这样，当您等待第一个Promise来解决其他异步调用时，其他异步调用仍在进行。总的来说，您将只等待最慢的异步调用。例如：
// Begin first call and store promise without waiting
const someResult = someCall();
// Begin second call and store promise without waiting
const anotherResult = anotherCall();
// Now we await for both results, whose async processes have already been started
const finalResult = [await someResult, await anotherResult];
// At this point all calls have been resolved
// Now when accessing someResult| anotherResult,
// you will have a value instead of a promise
JSbin示例：http://jsbin.com/xerifanima/edit?js安慰
注意：只要第一个等待调用发生在所有异步调用之后，那么等待调用是在同一条线上还是在不同的线上并不重要。见JohnnyHK的评论。
更新：根据@bergi的回答，这个答案在错误处理中的时间不同，它不会在错误发生时抛出错误，而是在所有承诺都执行后抛出错误。我将结果与@jonny的提示进行比较：[result1，result2]=Promise.all（[async1（），async2（）]），检查以下代码片段
常量correctAsync500ms=（）=>{return new Promise（解析=>{setTimeout（resolve，500，'correct500msResult'）；});};常量correctAsync100ms=（）=>{return new Promise（解析=>{setTimeout（resolve，100，'correct100msResult'）；});};常量拒绝同步100ms=（）=>{return new Promise（（resolve，reject）=>{setTimeout（拒绝，100，'拒绝100毫秒错误'）；});};const asyncInArray=异步（fun1，fun2）=>{const label='测试数组中的异步函数'；尝试{console.time（标签）；常量p1=fun1（）；常量p2=fun2（）；const result=[await p1，wait p2]；console.timeEnd（标签）；}捕获（e）{console.error（'错误为'，e）；console.timeEnd（标签）；}};常量asyncInPromiseAll=async（fun1，fun2）=>{const label='使用Promise.all测试异步函数'；尝试{console.time（标签）；let[value1，value2]=等待Promise。all（[fun1（），fun2（）]）；console.timeEnd（标签）；}捕获（e）{console.error（'错误为'，e）；console.timeEnd（标签）；}};（异步（）=>{console.group（'无错误的同步功能'）；console.log（'无错误的同步函数：启动'）等待异步InArray（correctAsync500ms，correctAsync 100ms）；等待异步InPromiseAll（correctAsync500ms，correctAsync 100ms）；console.groupEnd（）；console.group（'带错误的同步功能'）；console.log（'带有错误的同步函数：start'）等待异步InArray（correctAsync500ms，rejectAsync100ms）；等待异步InPromiseAll（correctAsync500ms，rejectAsync100ms）；console.groupEnd（）；})();
