When running with `Dispatchers.Main.immediate`, wh...

# coroutines

[ghedeon]

When running with Dispatchers.Main.immediate, what is the the best way to execute a portion immediately and launchAndForget the rest?
Ex:

suspended fun foo(){
    operationA()  // <--- don't wait for it, it's on IO
    operationB() // <--- post on Main immediately
}

It already works if I swap the order, like

operationB() // <--- post on Main immediately
    operationA()  // <--- don't wait for it, it's on IO

But I'm looking for a way that doesn't depend on the order of operations.

[louiscad]

Using another coroutine scope: a custom one (CoroutineScope(…)), or GlobalScope

[ghedeon]

Hmm, not sure if I got the idea.
Ex:

launch(Dispatchers.Main.immediate){
        operationA() // IO stuff
        operationB() // immediate stuff
}

How to make operationB() to post on main immediately? Wrap the operationA in another coroutine scope? Didn't work unfortunately

[louiscad]

Use launch to not wait for the completion of a child coroutine

[louiscad]

You can also take advantage of start = CoroutineStart.UNDISPATCHED as a parameter of launch.

[ghedeon]

GlobalScope.launch(Dispatchers.Main.immediate) {
            coroutineScope {
                launch(start = CoroutineStart.UNDISPATCHED, context = <http://Dispatchers.IO|Dispatchers.IO>) {
                    delay(1000)
                    println("third")
                }
            }
            println("first")
        }
        println("second")

This prints second third first

[louiscad]

Yes, because the local coroutineScope waits for its children

[louiscad]

Your use case is about breaking structuring concurrency, so you want a scope like CoroutineScope(<http://Dispatchers.IO|Dispatchers.IO>)

[ghedeon]

That did it. Thanks @louiscad!