A modern programming language that makes developers happier.

kotlinlang

Is there any benefit of using
```val a = async { … }
val b = async { … }
joinAll(a, b)
val a2 = a.getCompleted()
val b2 = b.getCompleted()```
instead of
```val a = async { … }
val b = async { … }
val a2 = a.await()
val b2 = b.await()```
?

I believe they are identical (at least in terms of concurrent execution and cancellation behavior).

It’s worth noting that `awaitAll` has a specific implementation that’s not just `forEach { it.await() }`, and that presumably has performance benefits associated with it. <https://github.com/Kotlin/kotlinx.coroutines/blob/master/kotlinx-coroutines-core/common/src/Await.kt#L60-L120>

Maybe in case of `CoroutineStart.LAZY` ? If you use a basic for-loop, they will end up being sequential :thinking_face:

But that's not used in my example, and even then, it wouldn't make a difference

<https://github.com/Kotlin/kotlinx.coroutines/blob/master/kotlinx-coroutines-core/common/src/Await.kt#L27-L28>

Yeah, that's along the lines of what I expected. Doesn't answer my question though.

I think it does start to answer it. One of the benefits of the second snippet over the first is that if the first deferred completes exceptionally, it will be thrown before the second deferred is awaited. In a scenario where the second deferred takes longer to complete than the first, you save time by not waiting for it to complete.

No? Both snippets are sequential, `joinAll` doesn't have all the things we mentioned that `awaitAll` has.

I was originally under the impression that `Deferred.join` wouldn't throw an exceptional result, but it looks like I'm wrong! If that's not the case I don't see a difference between these two.