Should I avoid doing this ``` launch { launch {} launch {} ...

# coroutines

[Justin]

Should I avoid doing this

launch {
            launch {}
            launch {}
            launch {}
        }.join()

over this?

listOf(
            launch {},
            launch {},
            launch {}
        ).joinAll()

Either way, why? Thanks!

[octylFractal]

the first one will have a bit more overhead since it still needs to do an initial async launch. probably the most kotlin-like way is:

coroutineScope {
  launch {}
  launch {}
  launch {}
}

[Justin]

oooooo, awesome, thanks!

[sikri]

afaik in option 1 you will wait only for outer launch to finish, not for inner launches
you HAVE to use coroutineScope as in previous answer or option 2

[Jorge Castillo]

What about this? Looks like you're wanting to do parallel ops and join results in the end

suspend fun concurrentSum(): Int = coroutineScope {
    val one = async { doSomethingUsefulOne() }
    val two = async { doSomethingUsefulTwo() }
    one.await() + two.await()
}

[Jorge Castillo]

That'd be what I'd expect if using kx.coroutines

[dekans]

If you're waiting for return values.
This is not the case here AFAIU

[Lukas Lechner]

@sikri

launch {
            launch {}
            launch {}
            launch {}
        }.join()

behaves in the exact same was as

coroutineScope {
  launch {}
  launch {}
  launch {}
}

[Lukas Lechner]

@sikri because of the principle of Structured Concurrency that a parent (outer launch) does not complete before all of its children (inner launches) have completed.

[sikri]

indeed, my mistake, i missed the join in option 1