Whats the difference b w `coroutineScope` and `launch` Its n

Question

Whats the difference b w `coroutineScope` and `launch` Its not super clear from the docs

gildor · Answer

What is similar between them

efemoney · Answer

Tbh I m not sure Stems from my mis understanding of `coroutineScope` I m not entirely sure what it does

gildor · Answer

thana · Answer

launch is a method the coroutineScope is provides this method to launch a coroutine in this scope

gildor · Answer

gt coroutineScope gt Creates a CoroutineScope and calls the specified suspend block with this scope gt This function is designed for parallel decomposition of work When any child coroutine in this scope fails this scope fails and all the rest of the children are cancelled for a different behavior see supervisorScope This function returns as soon as the given block and all its children coroutines are completed A usage example of a scope looks like this

thana · Answer

i guess there could be lots more of documentation of what is a CoroutineScope what is a CoroutineDispatcher how are they connect whats the difference and wahts a CCoroutineScope actually good for and how to use it

efemoney · Answer

< thana> not `CoroutineScope` I understand that Sorry I wasnt clear I meant the builder `coroutineScope `

efemoney · Answer

< gildor> Its sorta clear now but I need to clear something up Will `coroutineScope` suspend the ~thread~ coroutine it is running in I get its a suspend function but if above is true how then does it facilitate parallel decomposition

gildor · Answer

gt suspend the thread This statement is incorrect by definition you cannot suspend thread

gildor · Answer

it will suspend coroutine until all child coroutines are finished

gildor · Answer

it s true for all suspend functions they suspend coroutine until return

efemoney · Answer

Yeah thats what I thought and thats why I was a bit confused

efemoney · Answer

Yeah I know that

gildor · Answer

so because coroutineScope is suspend function it will suspend until block and all child coroutines are finished

efemoney · Answer

How then is it designed for parallel decomposition

gildor · Answer

see sample

gildor · Answer

you can run child coroutines using launch async and don t worry about leaks also it will wait until all of them are finished so you can just run 2 launch coroutines and do not use join coroutineScope will wait

gildor · Answer

gt designed for parallel decomposition It means that you do something in parallel inside of this block

efemoney · Answer

I see I keep falling into the trap of thinking its about the outer coroutine scope but it really is about the inner lambda one For my use case `launch` is what I need for a side effecty kind of thing

efemoney · Answer

Yeah I get it Thanks < gildor>

gildor · Answer

it doesn t make sense to just use launch you need multiple coroutines or some additional block

gildor · Answer

I mean `coroutineScope launch doSomething ` doesn t make sense

gildor · Answer

But this make sense ```coroutineScope launch doSomething doSomethingElse ```

efemoney · Answer

yeah thats not what i m doing

efemoney · Answer

I m doing a `launch ` instead of a `coroutineScope ` in the outer coroutine which is a launch btw It s all cleared up now really

gildor · Answer

+1

efemoney · Answer

But I can still explain what I wanted to achieve to make it super clear Maybe theres a better way to do what I wanted In my project I fetch some data say `description` and `startedAt` and I have to start a timer with the value of startedAt and set text with the value of description So ``` launch val data = getData suspend fun runTimer data startedAt settext data description elsewhere fun runTimer startedAt = launch or coroutineScope do timer things with ticker ``` My confusion was whether to wrap runTimer body in coroutineScope or not of course that wouldnt have worked because runTimer just runs a ticker that counts up forever suspending the parent coroutine and therefore never getting to setText

gildor · Answer

gt fun runTimer startedAt = launch This is not recommended style coroutineScope is recommended but it has very different sematics

efemoney · Answer

Okay that s what I m trying to find out now how should this be implemented I want to run a ticker within `runTimer` but it shouldn t suspend the parent coroutine because I still want to reach `setText` Also both `launch`es are called in a larger `CoroutineScope` my UI component so the `launch` is not necessarily just hanging

gildor · Answer

depends on runTimer implementation and how it should work

gildor · Answer

gt but it shouldn t suspend the parent coroutine because I still want to reach `setText` Recommended approach is launch runTimer data startedAt suspend fun runTimer startedAt

efemoney · Answer

gt depends on runTimer implementation and how it should work Think of it as a loop with `delay 1000 ` and `textView text = now startedAt`

gildor · Answer

yes than like I show above

gildor · Answer

is it infinite loop

gildor · Answer

If so you can just convert suspend function to CoroutineScope extension

gildor · Answer

like ```fun CoroutineScope runTimer Job return launch ```

gildor · Answer

now it follows convention of other Kotlinx coroutine builders

efemoney · Answer

gt Recommended approach is I see Why is this so much different from wrapping the body in launch The method is private so it wont be called from anywhere else

efemoney · Answer

Ah nice

gildor · Answer

To make it explicit

efemoney · Answer

Yeah that actually makes a lot of sense

gildor · Answer

that this method starts new background coroutine on target coroutine scope

efemoney · Answer

That is pretty clear Thanks < gildor>

gildor · Answer

Just one more reason that you explicitly specify scope instead hide it as implementatation detail so you can actually attach to to any scope like in your sample not only to top level one