If I'm creating a bunch of coroutines and doing a lot of work, should I be calling `yield()` every ...

# coroutines

[jeggy]

If I'm creating a bunch of coroutines and doing a lot of work, should I be calling yield() every now and then all around in the code, so if any cancelation is requested that all my coroutines will cancel? And if so, how expensive is it to call yield ?

[octylFractal]

it depends on how urgent it is that they be canceled - additionally, it's probably better to call ensureActive() because that won't suspend at all, unlike yield(). suspending is not too expensive, but it does stop work for a tiny bit

[jeggy]

So if I would have a loop of 100k and in each iteration I'm doing some work inside a coroutine. Would it make sense to then call ensureActive upon each iteration?

[octylFractal]

if you have something that could cancel that work and no other spot that checks for it, yes

[jeggy]

I'm building a GraphQL library, so what the exact work is is unknown. But I have some example where I would wrap it with withTimeout and then I had some problems with it that it still went on for some minutes after it should have been canceled. So I'm just trying to figure out what's the best way to really cancel the execution.

[octylFractal]

yea, use ensureActive then

[jeggy]

I think I will just call ensureActive() each time I'm calling the provided lambda by the user of this library 🙂

[jeggy]

Thanks for the help 👍

[octylFractal]

also, is the lambda suspending or blocking?

[jeggy]

suspending

[octylFractal]

alright then, if it was blocking I would suggest https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/run-interruptible.html as well

[jeggy]

fun resolver(function: suspend (T) -> R) This is the function I'm exposing from this library. But it could be that the code provided is using some blocking code.

[octylFractal]

I wouldn't worry about it too much

[jeggy]

I will just stick with ensureActive, and see how it works with big data sets