Discussion on "Coroutines racing! Why, and how." | Hashnode

Discussion

Louis CAD

Kotlin GDE

Nov 8, 2021

Coroutines racing! Why, and how.

Over the years, I found myself needing the following: Run multiple related coroutines (i.e. asynchronous operations), and when one completes, cancel/stop the other ones. As usual, and especially since we're in Kotlin, I have been looking for the easi...

blog.louiscad.com7 min read

#kotlin #coroutines #concurrency

Responses(3)

Louis CAD A (fixed) basic approach ;-)

suspend fun awaitTrigger1() { coroutineScope {
    val win = coroutineContext::cancelChildren
    launch { awaitAutomaticTrigger(); win(null) }
    launch { awaitManualTrigger(); win(null) }
} }

version with some result

suspend fun awaitTrigger2(): T = coroutineScope {
    val deferred = CompletableDeferred<T>()
    launch { deferred.complete(awaitAutomaticTrigger()) }
    launch { deferred.complete(awaitManualTrigger()) }
    deferred.await().also { coroutineContext.cancelChildren() }
}

pl.kotl.in/i1YWEs2lC pl.kotl.in/oQyBHb2bg

Marek Langiewicz

Kotlin

Nov 15, 2021

Same example with some result (for single thread dispatcher):

suspend fun awaitTrigger(): T {
    var t: T? = null
    coroutineScope {
        val scope = this
        launch { t = awaitAutomaticTrigger(); scope.cancel() }
        launch { t = awaitManualTrigger(); scope.cancel() }
    }
    return t!!
}

Louis CAD

Kotlin GDE

Nov 15, 2021

Can't work for the same reason as the other one you shared. For reference, here's a playground that proves it: pl.kotl.in/MArMNltGT

Marek Langiewicz

Kotlin

Nov 15, 2021

Why not just cancel the scope when a child wins? A basic approach:

suspend fun awaitTrigger() { coroutineScope {
    val scope = this
    launch { awaitAutomaticTrigger(); scope.cancel() }
    launch { awaitManualTrigger(); scope.cancel() }
} }

It should gracefully cancel all losers. Also more flexible: we can for example always wait for some specific slow child by skipping cancel invocation.

Marek Langiewicz

Kotlin

Nov 15, 2021

Louis CAD Yes, but that's fine because the winner already finished it's work (even though winner's Job is still active).

Louis CAD

Kotlin GDE

Nov 15, 2021

Marek Langiewicz Nope, the winner's job is not finished until after the launch block is complete, so cancellation happens before, so it cannot work.

Here's a playground that proves it: pl.kotl.in/MArMNltGT

Marek Langiewicz

Kotlin

Nov 15, 2021

Louis CAD You're right. It crashes. Looks like the coroutineScope {...} doesn't swollow cancellation (in this particular edge case) even when explicitly asked to cancel. I find it surprising because cancellation should be cooperative.. Even stranger thing is that when I change coroutineScope { ... } tolaunch { ... }.join() then it starts working as I expected in the first place. Either it's a bug in coroutines or I don't quite get all guarantees in coroutines machinery.

Search Hashnode

Coroutines racing! Why, and how.

Responses(3)

Recent in Forum