Call async await functions in parallel

Question

As far as I understand  in ES7 ES2016 putting multiple await s in code will work similar to chaining  then   with promises  meaning that they will execute one after the other rather than in parallel  So  for example  we have this code  await someCall    await anotherCall     Do I understand it correctly that anotherCall   will be called only when someCall   is completed  What is the most elegant way of calling them in parallel  I want to use it in Node  so maybe there s a solution with async library  EDIT  I m not satisfied with the solution provided in this question  Slowdown due to non-parallel awaiting of promises in async generators  because it uses generators and I m asking about a more general use case

User · Answer

I create a helper function waitAll  may be it can make it sweeter  It only works in nodejs for now  not in browser chrome         const parallel   async     items    gt        const waitAll   async     items    gt              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

User · Answer

TL DR  Use Promise all for the parallel function calls  the answer behaviors not correctly when the error occurs     First  execute all the asynchronous calls at once and obtain all the Promise objects  Second  use await on the Promise objects  This way  while you wait for the first Promise to resolve the other asynchronous calls are still progressing  Overall  you will only wait for as long as the slowest asynchronous call  For example      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 example  http   jsbin com xerifanima edit js console  Caveat  It doesn t matter if the await calls are on the same line or on different lines  so long as the first await call happens after all of the asynchronous calls  See JohnnyHK s comment     Update  this answer has a different timing in error handling according to the  bergi s answer  it does NOT throw out the error as the error occurs but after all the promises are executed   I compare the result with  jonny s tip   result1  result2    Promise all  async1    async2      check the following code snippet   x000D   x000D  const correctAsync500ms        gt    x000D    return new Promise resolve   gt    x000D      setTimeout resolve  500   correct500msResult    x000D        x000D     x000D   x000D  const correctAsync100ms        gt    x000D    return new Promise resolve   gt    x000D      setTimeout resolve  100   correct100msResult    x000D        x000D     x000D   x000D  const rejectAsync100ms        gt    x000D    return new Promise  resolve  reject    gt    x000D      setTimeout reject  100   reject100msError    x000D        x000D     x000D   x000D  const asyncInArray   async  fun1  fun2    gt    x000D    const label    test async functions in array   x000D    try   x000D      console time label   x000D      const p1   fun1    x000D      const p2   fun2    x000D      const result    await p1  await p2   x000D      console timeEnd label   x000D      catch  e    x000D      console error  error is   e   x000D      console timeEnd label   x000D      x000D     x000D   x000D  const asyncInPromiseAll   async  fun1  fun2    gt    x000D    const label    test async functions with Promise all   x000D    try   x000D      console time label   x000D      let  value1  value2    await Promise all  fun1    fun2      x000D      console timeEnd label   x000D      catch  e    x000D      console error  error is   e   x000D      console timeEnd label   x000D      x000D     x000D   x000D   async      gt    x000D    console group  async functions without error    x000D    console log  async functions without error  start   x000D    await asyncInArray correctAsync500ms  correctAsync100ms   x000D    await asyncInPromiseAll correctAsync500ms  correctAsync100ms   x000D    console groupEnd    x000D   x000D    console group  async functions with error    x000D    console log  async functions with error  start   x000D    await asyncInArray correctAsync500ms  rejectAsync100ms   x000D    await asyncInPromiseAll correctAsync500ms  rejectAsync100ms   x000D    console groupEnd    x000D        x000D   x000D   x000D

User · Answer

Update   The original answer makes it difficult  and in some cases impossible  to correctly handle promise rejections  The correct solution is to use Promise all   const  someResult  anotherResult    await Promise all  someCall    anotherCall        Original answer   Just make sure you call both functions before you await either one      Call both functions const somePromise   someCall    const anotherPromise   anotherCall        Await both promises     const someResult   await somePromise  const anotherResult   await anotherPromise

User · Answer

In my case  I have several tasks I want to execute in parallel  but I need to do something different with the result of those tasks    function wait ms  data        console log  Starting task    data  ms       return new Promise resolve   gt  setTimeout resolve  ms  data       var tasks         async      gt            var result   await wait 1000   moose               do something with result         console log result              async      gt            var result   await wait 500   taco               do something with result         console log result              async      gt            var result   await wait 5000   burp               do something with result         console log result            await Promise all tasks map p   gt  p      console log  done      And the output    Starting task  moose 1000 Starting task  taco 500 Starting task  burp 5000 taco moose burp done

User · Answer

await Promise all  someCall    anotherCall      as already mention will act as a thread fence  very common in parallel code as CUDA   hence it will allow all the promises in it to run without blocking each other  but will prevent the execution to continue until ALL are resolved   another approach that is worth to share is the Node js async that will also allow you to easily control the amount of concurrency that is usually desirable if the task is directly linked to the use of limited resources as API call  I O operations  etc      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          Credits to the Medium article autor  read more

User · Answer

A generic test function that can be configured         with an arbitrary delay and to either resolve or reject     const test    delay  resolveSuccessfully    gt  new Promise  resolve  reject    gt  setTimeout      gt            console log  Done    delay              resolveSuccessfully   resolve  Resolved    delay       reject  Reject    delay            delay            Our async handler function     const handler   async      gt               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   gt  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          Whilst setting p1  p2 and p3 is not strictly running them in parallel  they do not hold up any execution and you can trap contextual errors with a catch

User · Answer

You can await on Promise all    await Promise all  someCall    anotherCall       To store the results  let  someResult  anotherResult    await Promise all  someCall    anotherCall       Note that Promise all fails fast  which means that as soon as one of the promises supplied to it rejects  then the entire thing rejects   x000D   x000D  const happy    v  ms    gt  new Promise  resolve    gt  setTimeout      gt  resolve v   ms   const sad    v  ms    gt  new Promise     reject    gt  setTimeout      gt  reject v   ms    Promise all  happy  happy   100   sad  sad   50       then console log  catch console log      sad  x000D   x000D   x000D   If  instead  you want to wait for all the promises to either fulfill or reject  then you can use Promise allSettled  Note that Internet Explorer does not natively support this method   x000D   x000D  const happy    v  ms    gt  new Promise  resolve    gt  setTimeout      gt  resolve v   ms   const sad    v  ms    gt  new Promise     reject    gt  setTimeout      gt  reject v   ms    Promise allSettled  happy  happy   100   sad  sad   50       then console log         status   fulfilled    value   happy        status   rejected    reason   sad     x000D   x000D   x000D    Note  If you use Promise all actions that managed to finish before rejection happen are not rolled back  so you may need to take care of such situation  For example if you have 5 actions  4 quick  1 slow and slow rejects  Those 4 actions may be already executed so you may need to roll back  In such situation consider using Promise allSettled while it will provide exact detail which action failed and which not

User · Answer

I ve created a gist testing some different ways of resolving promises  with results  It may be helpful to see the options that work

User · Answer

There is another way without Promise all   to do it in parallel   First  we have 2 functions to print numbers   function printNumber1        return new Promise  resolve reject    gt          setTimeout      gt          console log  Number1 is done          resolve 10           1000             function printNumber2        return new Promise  resolve reject    gt          setTimeout      gt          console log  Number2 is done          resolve 20           500              This is sequential   async function oneByOne        const number1   await printNumber1       const number2   await printNumber2         Output  Number1 is done  Number2 is done   This is parallel   async function inParallel        const promise1   printNumber1       const promise2   printNumber2       const number1   await promise1     const number2   await promise2      Output  Number2 is done  Number1 is done

User · Answer

I vote for   await Promise all  someCall    anotherCall        Be aware of the moment you call functions  it may cause unexpected result      Supposing anotherCall   will trigger a request to create a new User  if  callFirst      await someCall      else     await Promise all  someCall    anotherCall         -- gt  create new User here     But following always triggers request to create new User     Supposing anotherCall   will trigger a request to create a new User  const someResult   someCall    const anotherResult   anotherCall       - gt  gt  This always creates new User  if  callFirst      await someCall      else     const finalResult    await someResult  await anotherResult

[javascript] Call async/await functions in parallel

Examples related to javascript

Examples related to node.js

Examples related to asynchronous

Examples related to ecmascript-6

Examples related to babeljs