Sanity check time If I have this suspend function ``` suspen

Question

Sanity check time If I have this suspend function ``` suspend fun doSomeWork coroutineScope launch suspendFunciton1 coroutineScope launch suspendFunciton2 ``` Can anyone confirm that I m correct about these statements or am I somehow reading my test results wrong 1 If I start `doSomeWork` with `viewModelScope` for example then `suspendFunction1 ` and `2 ` will both be started with that same `viewModelScope` to initiate `doSomeWork` 2 `suspendFunction1 ` and `2 ` will run in parrallel 3 `doSomeWork` won t complete until `suspendFunction1 ` and `2 ` complete

Dominaezzz · Answer

Statement 3 is wrong

ephemient · Answer

2 viewModelScope `uses Dispatchers Main immediate` which is a single thread 3 no using another scope breaks the connection with the current one

Dominaezzz · Answer

Statement 2 is correct if you say concurrent instead of parallel

Colton Idle · Answer

Do any of your responses change if I say that suspendFunction1 and 2 are retrofit networking calls So they will run off the main thread smile

ephemient · Answer

assuming you re not using blocking retrofit calls 2 changes but not 3

Colton Idle · Answer

Re 3 Damn back to the drawing board then How would I get this to be playing within the bounds of structured concurrency

Colton Idle · Answer

just ``` suspend fun doSomeWork viewModelScope launch suspendFunciton1 viewModelScope launch suspendFunciton2 ```

Dominaezzz · Answer

Easy `coroutineScope launch launch `

Colton Idle · Answer

< Dominaezzz> isn t that essentially what I already have

Colton Idle · Answer

oh jeeeeez i copy pastad the wrong code

Colton Idle · Answer

face palm

Colton Idle · Answer

this is what i meant to have put here If I have this suspend function ``` suspend fun doSomeWork coroutineScope launch suspendFunciton1 coroutineScope launch suspendFunciton2 ``` Can anyone confirm that I m correct about these statements or am I somehow reading my test results wrong 1 If I start `doSomeWork` with `viewModelScope` for example then `suspendFunction1 ` and `2 ` will both be started with that same `viewModelScope` to initiate `doSomeWork` 2 `suspendFunction1 ` and `2 ` will run in parrallel 3 `doSomeWork` won t complete until `suspendFunction1 ` and `2 ` complete

ephemient · Answer

2 is wrong for a different reason now

Dominaezzz · Answer

I need to go I ll leave the rest to ephemient slightly smiling face

ephemient · Answer

the first call to coroutineScope will not resume the next statement in doSomeWork until the launch inside has completed

ephemient · Answer

what you ve written there is equivalent to ```suspend fun doSomeWork suspendFunction1 suspendFunction2 ``` just with some extra machinery

Colton Idle · Answer

isn t that ^ just procedural code though

Colton Idle · Answer

I guess my real goal is to just have doSomeWork call two network calls so they run in parrallel lol

ephemient · Answer

launch them from the same child scope then

ephemient · Answer

with two scopes you re just writing sequential code in a more confusing way

Colton Idle · Answer

So just what Dominic said `coroutineScope launch launch `

Colton Idle · Answer

I swear with coroutines I feel like I have it figured out then I m met with something simple like this and i feel like an idiot face palm

Patrick Steiger · Answer

If you want to do parallel decomposition of work opening a new scope and launching coroutines inside it is the way to go

Patrick Steiger · Answer

Because a scope returns only when all children finish the enclosing suspend fun will also only finish when scope returns hence when all children finish

ephemient · Answer

strictly speaking launch gives you concurrency not necessarily parallelism that may optionally come from the dispatcher

Patrick Steiger · Answer

There are a number of coroutine scope builders like `coroutineScope ` `supervisorScope` or `withContext`

Colton Idle · Answer

Alright So this is more like what I m after ``` suspend fun doSomeWork coroutineScope launch suspendFunciton1 launch suspendFunciton2 ```

Patrick Steiger · Answer

< ephemient> I think the opposite is true When you are under a single threaded dispatcher you get coroutines running in parallel while one has not finished yet the other might start running but not at the same time there is only one thread available But don t quote me on that my brains always go shenanigans when concurrent vs parallel differences and I might be exchanging those terms

Colton Idle · Answer

And so something like this would be bad because I m breaking structured concurrency ``` suspend fun doSomeWork viewModelScope launch launch suspendFunciton1 launch suspendFunciton2 ```

ephemient · Answer

I often write ```suspend fun foo = coroutineScope ``` since it s a relatively common pattern to want a scope with the same lifetime as the function call

ephemient · Answer

Patrick Steiger · Answer

< Colton Idle> yes the last snipped you sent is bad because the suspend fun will return without waiting for the launched coroutines to finish

ephemient · Answer

coroutines interleaving with each other at suspend points on a single thread dispatcher is concurrency not parallelism

Patrick Steiger · Answer

So parallel coroutines require 2+ threads

Patrick Steiger · Answer

Then I suppose Kdoc of `coroutineScope` is wrong because it talks about parallel decomposition of work

Colton Idle · Answer

thanks everyone for the saturday convo learn something new every day smile

Colton Idle · Answer

oh one last thing in ``` suspend fun doSomeWork coroutineScope launch suspendFunciton1 launch suspendFunciton2 ``` the two inner suspend functions will be cancelled if the outer syspend function is cancelled right in other words if i initially called doSomeWork with viewModelScope then the two inner suspend are called with that same scope no

Patrick Steiger · Answer

Yes When you open a scope with `coroutineScope` the job of this scope is a child of the job of the enclosing suspend fun

Patrick Steiger · Answer

And the job of the inner launches are children of the `coroutineScope ` job

Colton Idle · Answer

okay bear with me one last question if this happens in parallel ``` suspend fun doSomeWork coroutineScope launch suspendFunciton1 launch suspendFunciton2 ``` why wouldn t this be in parallel ``` suspend fun doSomeWork coroutineScope launch suspendFunciton1 coroutineScope launch suspendFunciton2 ```

Colton Idle · Answer

oh yeah because like Patrick said only once a coroutineScope is completely done with its work does it return

Colton Idle · Answer

okay i think i get it now

Patrick Steiger · Answer

Yes To get more technical once the work immediately on the coroutineScope lambda gets done it s job moves it s state to Completing if it still has children jobs doing work Active Once all children move to Completed then the coroutineScope job moves from Completing to Completed and only then it returns

Patrick Steiger · Answer

Job lifecycle is the key to understand all that s going on in there structured concurrency

Patrick Steiger · Answer

Completing means I m done but my children are not

Patrick Steiger · Answer

Completed means me and my children are done

Patrick Steiger · Answer

Reading JobSupport KDoc is really helpful

Colton Idle · Answer

Now another variation of my question if I have ``` suspend fun doSomeWork coroutineScope launch suspendFunciton1 launch suspendFunciton2 ``` how would I now be able to use their returns once both of them return This works for me but curiuos if theres some other standard way ``` suspend fun doSomeWork Pair lt MyType OtherType gt var one MyType = null var two OtherType = null coroutineScope launch one = suspendFunciton1 launch two = suspendFunciton2 return Pair one two ```

Patrick Steiger · Answer

```suspend fun doSomeWork = coroutineScope val one = async susFun1 val two = async susFun2 one await to two await ```

Dominaezzz · Answer

``` suspend fun doSomeWork Pair lt MyType OtherType gt coroutineScope val one = async suspendFunciton1 val two = async suspendFunciton2 Pair one await two await ```

Colton Idle · Answer

danke

ephemient · Answer

as there are appropriate contracts on the scope builders ```val first Type1 val second Type2 coroutineScope val firstAsync = async suspendFunction1 val second Async = async suspendFunction2 first = firstAsync await second = secondAsync await first and second are now initialized ``` works destructuring an intermediate data structure is easier if an appropriate one exists but this is an alternative if you have many different types