Why not just rewrite it like: ``` val first: Deferred<Unit> = async { firstTask().let { d...

# coroutines

[gildor]

Why not just rewrite it like:

val first:  Deferred<Unit> = async { 
   firstTask().let { doFirstStuff() }
}
val second: Deferred<Unit> = async {    
    secondTask().let { doSecondStuff() }
}
first.await()
second.await()

[Bjarne Gelotte]

Ah I see. doFirstStuff and doSecondStuff needs to be done on the UI thread in my case. In this example they will be called on another thread, right?

[gildor]

You can run them on any thread

[gildor]

just use

withContext(UI) { doFirstStuff() }

[gildor]

also if you do this for UI don’t forget to manage UI lifecycle (probably you want to cancel those tasks in case of UI destroy)

[gildor]

But you right, async by default runs all the task on CommonPool dispatcher

[Bjarne Gelotte]

Ah thanks 🙂 I think maybe in my case another launch will be useful. But I wasn't sure if nestled launches is good/idiomatic

[gildor]

nested launch? I don’t see why do you need nested launch

[gildor]

I mean:

launch {
    val result = firstTask()
    withContext(UI) { result.doFirstStuff() }
}
launch {
    val result = secondTask()
    withContext(UI) { result.doSecondStuff() }
}

[gildor]

Or in opposite way, you can use UI context for launch and wrap secondTask (it’s not always necessary, depends on what firstTask/secondTask does)

[Bjarne Gelotte]

In my case I'm already inside a launch. But I should probably go back and refactor when I start the first launch

[gildor]

Oh, I see, yes, of course choice between async/launch/withContext always based on your case and what is more convenient and correct for your semantics

[gildor]

nothing wrong with nested launch if it works for you. It’s just one coroutine just starts some child coroutines

[Bjarne Gelotte]

Ok! I think this last example will work nicely in my case if I restructure the code a bit. Thanks a lot!