What s the difference between executing some operations in a

Question

What s the difference between executing some operations in a `coroutineScope ` vs just executing them in the outer scope Assuming the outer context has a regular `Job`

Big Chungus · Answer

The first option will suspend until all jobs launched inside complete

natario1 · Answer

Wouldn t that happen anyway E g ```suspendFun0 suspendFun1 withContext otherContext suspendFun2 ``` vs ```coroutineScope suspendFun0 suspendFun1 withContext otherContext suspendFun2 ``` In both cases I reach the end of the code when all ops have finished Or get an exception if they fail And since we have a regular `Job` in both cases failure of any child will cancel everything else just maybe in a different order in both cases

natario1 · Answer

My feeling is that the point of `coroutineScope ` is just to ensure that current job is a `Job ` not supervised so if you already know that coroutineScope is useless I can t tell whether this is the case from documentation though

Big Chungus · Answer

Yes for this case but consider another case ```fun CoroutineScope test1 suspendFun1 suspends launch does not suspend suspendFun2 executes basically immediately after suspendFun1 and suspends again returns after suspendFun2 resumes does not wait for launched job suspend fun test2 coroutineScope suspendFun1 suspends launch does not suspend suspendFun2 executes basically immediately after suspendFun1 and suspends again suspends until all things inside resume including launched job returns after coroutineScope resumes ```

Alex Vasilkov · Answer

`coroutineScope` is used when you need access to a scope to launch other jobs if you just need to launch a few suspending functions then you don t need it indeed

Albert Chang · Answer

Sometimes you don t have an outer scope e g in a suspend fun If you want to use `launch` `async` in a suspend fun you have to use `coroutineScope`

Big Chungus · Answer

As docs state coroutineScope amp supervisorScope are to be used for parallel decomposition of work It s a way to wrap multiple parallel coroutines that all need to complete before the block can move on

Big Chungus · Answer

Let s say you want to print all values in massive list To speed things up you could parallelise it ```suspend fun printAllValues list List lt Any gt val workerCount = 5 val chunks = list chunk list size 5 coroutineScope repeat workerCount i gt launch Prints each chunk in parallel chunks i forEach println will return once ALL chunks are printed ```

natario1 · Answer

Got it Thank you guys The example in the function documentation could be much better It doesn t show any `launch` it shows an `async` but it then uses `async await ` so basically makes it look like a regular scope

Erik · Answer

You can always open an issue in the Kotlin coroutines repo to request documentation enhancements <https github com Kotlin kotlinx coroutines > Or just contribute yourself

natario1 · Answer

I m pretty busy with my `Job` slightly smiling face but thanks for helping