``` fun main runBlocking val job = launch suspendCoroutine l

Question

``` fun main runBlocking val job = launch suspendCoroutine lt Unit gt yield job cancel println goodbye println exit ``` prints ``` goodbye ``` and then hangs forever Does anybody know why this happens When removing the `yield ` it just works as expected

sitepodmatt · Answer

``` fun main argv Array lt String gt runBlocking val job = launch suspendCoroutine lt Unit gt continuation gt continuation resume Unit yield job cancel println goodbye println exit ```

sitepodmatt · Answer

in your original example suspendCorountione wasn t created before the job was cancelled

streetsofboston · Answer

Hmmm All the runBlocking s child routines end one by being cancelled and runBlocking should too What happens if you put a Thread sleep or delay in the suspendedCoroutine but still without calling resume

sitepodmatt · Answer

because the dispatcher of runBlocking run everything on the same thread

sitepodmatt · Answer

when you added yield it was able to create it

sitepodmatt · Answer

but suspendCorotuine didnt finish because you didnt resume the continuation

ribesg · Answer

< sitepodmatt> note you can use the item just below Unread messages on the top left of Slack to view threads in full width

sitepodmatt · Answer

so the the runBlocking waits for a children to finish which it never would

trathschlag · Answer

But the coroutine should be cancelled even if it is suspended My real usecase is more like this ``` suspendCoroutine lt Unit gt continuation gt performPotentiallyNeverEndingStuff callback = continuation resume Unit ``` Which effectively has the same problem

sitepodmatt · Answer

you need a suspendCancellableCoroutine

sitepodmatt · Answer

```un main argv Array lt String gt runBlocking val job = launch suspendCancellableCoroutine lt Unit gt yield job cancel println goodbye println exit ```

trathschlag · Answer

Nice this is what I was looking for Thanks

streetsofboston · Answer

Still though why did the original code then work when it has that yield call

trathschlag · Answer

It was the other way around It did not work when the yield was invoked And without the yield the `runBlocking` body was never suspended so the job did not even start executing before it was cancelled again So the non cancellable `suspendCoroutine` did not start and didn t block the cancellation of the job

trathschlag · Answer

``` fun main argv Array lt String gt runBlocking val job = launch Dispatchers Default suspendCoroutine lt Unit gt job cancel println goodbye println exit ``` This sometimes blocks and sometimes not because if the default dispatcher manages to execute `suspendCoroutine` before the `runBlocking` finishes the job is non cancellable again

streetsofboston · Answer

That would explain it Still I think it should not matter whether the dispatcher managed to execute suspendCoroutine or not early on The launch is called it is not lazy and the job should be considered either always running or always not running not sometimes the one and sometimes the other