并行调用 async/await 函数

您可以在 Promise.all() 上等待：

await Promise.all([someCall(), anotherCall()]);

存储结果：

let [someResult, anotherResult] = await Promise.all([someCall(), anotherCall()]);

请注意，Promise.all 快速失败，这意味着一旦提供给它的承诺之一拒绝，那么整个事情都会拒绝。

const happy = (v, ms) => new Promise((resolve) => setTimeout(() => resolve(v), ms)) const sad = (v, ms) => new Promise((_, reject) => setTimeout(() => reject(v), ms)) Promise.all([happy('happy', 100), sad('sad', 50)]) .then(console.log).catch( console.log) // '悲伤'

相反，如果您想等待所有承诺履行或拒绝，那么您可以使用 Promise.allSettled。请注意，Internet Explorer 本身并不支持此方法。

const happy = (v, ms) => new Promise((resolve) => setTimeout(() => resolve(v), ms)) const sad = (v, ms) => new Promise((_, reject) => setTimeout(() => reject(v), ms)) Promise.allSettled([happy('happy', 100), sad('sad', 50)]) .then(console.log) // [ {“状态”：“完成”，“价值”：“快乐”}，{“状态”：“拒绝”，“原因”：“悲伤”}]

注意：如果您使用 Promise，所有在拒绝发生之前成功完成的操作都不会回滚，因此您可能需要注意这种情况。例如，如果您有 5 个动作，4 个快速，1 个慢速和慢速拒绝。这 4 个操作可能已经执行，因此您可能需要回滚。在这种情况下，请考虑使用 Promise.allSettled ，同时它将提供哪些操作失败和哪些失败的确切细节。

---

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,console

警告： await 调用是在同一行还是在不同的行并不重要，只要第一个 await 调用发生在之后所有异步调用。请参阅 JohnnyHK 的评论。

更新： 根据 @bergi's answer，此答案在错误处理方面有不同的时间，它确实 不 在发生错误时抛出错误，但在执行所有承诺之后.我将结果与@jonny 的提示进行比较：[result1, result2] = Promise.all([async1(), async2()])，检查以下代码片段

const correctAsync500ms = () => { return new Promise(resolve => { setTimeout(resolve, 500, 'correct500msResult'); }); }; const correctAsync100ms = () => { return new Promise(resolve => { setTimeout(resolve, 100, 'correct100msResult'); }); }; const rejectAsync100ms = () => { return new Promise((resolve, reject) => { setTimeout(reject, 100, 'reject100msError'); }); }; const asyncInArray = async (fun1, fun2) => { const label = '测试数组中的异步函数';尝试 { 控制台时间（标签）；常量 p1 = fun1();常量 p2 = fun2();常量结果 = [等待 p1，等待 p2];控制台.timeEnd（标签）； } catch (e) { console.error('error is', e);控制台.timeEnd（标签）； } }; const asyncInPromiseAll = async (fun1, fun2) => { const label = '用 Promise.all 测试异步函数';尝试 { 控制台时间（标签）；让 [value1, value2] = await Promise.all([fun1(), fun2()]);控制台.timeEnd（标签）； } catch (e) { console.error('error is', e);控制台.timeEnd（标签）； } }; (async () => { console.group('async functions without error'); console.log('async functions without error: start') await asyncInArray(correctAsync500ms, correctAsync100ms); await asyncInPromiseAll(correctAsync500ms, correctAsync100ms); console. groupEnd(); console.group('async functions with error'); console.log('async functions with error: start') await asyncInArray(correctAsync500ms, rejectAsync100ms); await asyncInPromiseAll(correctAsync500ms, rejectAsync100ms); console.groupEnd() ; })();

---

更新：

最初的答案使得正确处理承诺拒绝变得困难（并且在某些情况下是不可能的）。正确的解决方案是使用 Promise.all：

const [someResult, anotherResult] = await Promise.all([someCall(), anotherCall()]);

原答案：

只需确保在等待任一函数之前调用这两个函数：

// Call both functions
const somePromise = someCall();
const anotherPromise = anotherCall();

// Await both promises    
const someResult = await somePromise;
const anotherResult = await anotherPromise;

---

还有另一种没有 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

---

我创建了 a gist，测试了一些解决承诺的不同方法，并得到了结果。查看有效的选项可能会有所帮助。

编辑：根据 Jin Lee 的评论提供内容

// Simple gist to test parallel promise resolution when using async / await

function promiseWait(time) {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
        resolve(true);
    }, time);
});
}


async function test() {
    return [
    await promiseWait(1000),
    await promiseWait(5000),
    await promiseWait(9000),
    await promiseWait(3000),
    ]
}

async function test2() {
    return {
        'aa': await promiseWait(1000),
        'bb': await promiseWait(5000),
        'cc': await promiseWait(9000),
        'dd': await promiseWait(3000),
    }
}

async function test3() {
    return await {
        'aa': promiseWait(1000),
        'bb': promiseWait(5000),
        'cc': promiseWait(9000),
        'dd': promiseWait(3000),
    }
}

async function test4() {
    const p1 =  promiseWait(1000);
    const p2 =  promiseWait(5000);
    const p3 =  promiseWait(9000);
    const p4 =  promiseWait(3000);
    return {
        'aa': await p1,
        'bb': await p2,
        'cc': await p3,
        'dd': await p4,
    };
}

async function test5() {
    return await Promise.all([
                             await promiseWait(1000),
                             await promiseWait(5000),
                             await promiseWait(9000),
                             await promiseWait(3000),
                             ]);
}

async function test6() {
    return await Promise.all([
                             promiseWait(1000),
                             promiseWait(5000),
                             promiseWait(9000),
                             promiseWait(3000),
                             ]);
}

async function test7() {
    const p1 =  promiseWait(1000);
    const p2 =  promiseWait(5000);
    const p3 =  promiseWait(9000);
    return {
        'aa': await p1,
        'bb': await p2,
        'cc': await p3,
        'dd': await promiseWait(3000),
    };
}

let start = Date.now();

test().then((res) => {
    console.log('Test Done, elapsed', (Date.now() - start) / 1000, res);

    start = Date.now();
    test2().then((res) => {
        console.log('Test2 Done, elapsed', (Date.now() - start) / 1000, res);

        start = Date.now();
        test3().then((res) => {
            console.log('Test3 Done, elapsed', (Date.now() - start) / 1000, res);

            start = Date.now();
            test4().then((res) => {
                console.log('Test4 Done, elapsed', (Date.now() - start) / 1000, res);

                start = Date.now();
                test5().then((res) => {
                    console.log('Test5 Done, elapsed', (Date.now() - start) / 1000, res);

                    start = Date.now();
                    test6().then((res) => {
                        console.log('Test6 Done, elapsed', (Date.now() - start) / 1000, res);
                    });

                    start = Date.now();
                    test7().then((res) => {
                        console.log('Test7 Done, elapsed', (Date.now() - start) / 1000, res);
                    });
                });
            });

        });
    });

});
/*
Test Done, elapsed 18.006 [ true, true, true, true ]
Test2 Done, elapsed 18.009 { aa: true, bb: true, cc: true, dd: true }
Test3 Done, elapsed 0 { aa: Promise { <pending> },
  bb: Promise { <pending> },
  cc: Promise { <pending> },
  dd: Promise { <pending> } }
Test4 Done, elapsed 9 { aa: true, bb: true, cc: true, dd: true }
Test5 Done, elapsed 18.008 [ true, true, true, true ]
Test6 Done, elapsed 9.003 [ true, true, true, true ]
Test7 Done, elapsed 12.007 { aa: true, bb: true, cc: true, dd: true }
*/

---

就我而言，我有几个要并行执行的任务，但我需要对这些任务的结果做一些不同的事情。

function wait(ms, data) {
    console.log('Starting task:', data, ms);
    return new Promise(resolve => setTimeout(resolve, ms, data));
}

var tasks = [
    async () => {
        var result = await wait(1000, 'moose');
        // do something with result
        console.log(result);
    },
    async () => {
        var result = await wait(500, 'taco');
        // do something with result
        console.log(result);
    },
    async () => {
        var result = await wait(5000, 'burp');
        // do something with result
        console.log(result);
    }
]

await Promise.all(tasks.map(p => p()));
console.log('done');

和输出：

Starting task: moose 1000
Starting task: taco 500
Starting task: burp 5000
taco
moose
burp
done

(async function(){ function wait(ms, data) { console.log('Starting task:', data, ms); return new Promise(resolve => setTimeout(resolve, ms, data)); } var tasks = [ async () => { var result = await wait(1000, 'moose'); // 对结果做一些事情 console.log(result); }, async () => { var result = await wait(500, ' taco'); // 对结果执行操作 console.log(result); }, async () => { var result = await wait(5000, 'burp'); // 对结果执行操作 console.log(result) ; } ] 等待 Promise.all(tasks.map(p => p())); console.log('done'); })();

---

等待 Promise.all([someCall(), anotherCall()]);正如已经提到的，它将充当线程围栏（在并行代码中非常常见，如 CUDA），因此它将允许其中的所有 Promise 运行而不会相互阻塞，但会阻止执行继续，直到解决所有问题。

另一种值得分享的方法是 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 文章作者 (read more)

---

    // A generic test function that can be configured 
    // with an arbitrary delay and to either resolve or reject
    const test = (delay, resolveSuccessfully) => new Promise((resolve, reject) => setTimeout(() => {
        console.log(`Done ${ delay }`);
        resolveSuccessfully ? resolve(`Resolved ${ delay }`) : reject(`Reject ${ delay }`)
    }, delay));

    // Our async handler function
    const handler = async () => {
        // Promise 1 runs first, but resolves last
        const p1 = test(10000, true);
        // Promise 2 run second, and also resolves
        const p2 = test(5000, true);
        // Promise 3 runs last, but completes first (with a rejection) 
        // Note the catch to trap the error immediately
        const p3 = test(1000, false).catch(e => console.log(e));
        // Await all in parallel
        const r = await Promise.all([p1, p2, p3]);
        // Display the results
        console.log(r);
    };

    // Run the handler
    handler();
    /*
    Done 1000
    Reject 1000
    Done 5000
    Done 10000
    */

虽然设置 p1、p2 和 p3 并不是严格地并行运行它们，但它们不会阻止任何执行，您可以使用 catch 捕获上下文错误。

---

您可以调用多个异步函数而无需等待它们。这将并行执行它们。这样做时，将返回的 Promise 保存在变量中，并在某个时候单独或使用 Promise.all() 等待它们并处理结果。

您还可以使用 try...catch 包装函数调用以处理单个异步操作的失败并提供回退逻辑。

这是一个示例：观察日志，在各个异步函数执行开始时打印的日志会立即打印，即使第一个函数需要 5 秒才能解决。

function someLongFunc () { return new Promise((resolve, reject)=> { console.log('Executing function 1') setTimeout(resolve, 5000) }) } function anotherLongFunc () { return new Promise((resolve, reject) => { console.log('Executing function 2') setTimeout(resolve, 5000) }) } async function main () { let someLongFuncPromise, anotherLongFuncPromise const start = Date.now() try { someLongFuncPromise = someLongFunc() } catch ( ex) { console.error('func 1 期间出现问题') } try { anotherLongFuncPromise = anotherLongFunc() } catch (ex) { console.error('func 2 期间出现问题') } await someLongFuncPromise await anotherLongFuncPromise const totalTime = Date.now() - start console.log('Execution completed in ', totalTime) } main()

---

我创建了一个辅助函数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());

---

我投票赞成：

await Promise.all([someCall(), anotherCall()]);

注意你调用函数的那一刻，它可能会导致意想不到的结果：

// Supposing anotherCall() will trigger a request to create a new User

if (callFirst) {
  await someCall();
} else {
  await Promise.all([someCall(), anotherCall()]); // --> create new User here
}

但是跟随总是触发创建新用户的请求

// Supposing anotherCall() will trigger a request to create a new User

const someResult = someCall();
const anotherResult = anotherCall(); // ->> This always creates new User

if (callFirst) {
  await someCall();
} else {
  const finalResult = [await someResult, await anotherResult]
}

---