After a coroutine scope is canceled, can it still be used again?

user_3286489 0
Viewed 6610

When we have a coroutine scope, when it is canceled, can it be used again?

e.g. for the below, when I have scope.cancel, the scope.launch no longer work

    @Test
    fun testingLaunch() {
        val scope = MainScope()
        runBlocking {
            scope.cancel()
            scope.launch {
                try {
                    println("Start Launch 2")
                    delay(200)
                    println("End Launch 2")
                } catch (e: CancellationException) {
                    println("Cancellation Exception")
                }
            }.join()

            println("Finished")
        }
    }

Similarly, when we have scope.cancel before await called,

    @Test
    fun testingAsync() {
        val scope = MainScope()
        runBlocking {
            scope.cancel()
            val defer = scope.async {
                try {
                    println("Start Launch 2")
                    delay(200)
                    println("End Launch 2")
                } catch (e: CancellationException) {
                    println("Cancellation Exception")
                }
            }
            defer.await()
            println("Finished")
        }
    }

It will not execute. Instead, it will crash with

kotlinx.coroutines.JobCancellationException: Job was cancelled
; job=SupervisorJobImpl{Cancelled}@39529185
    at kotlinx.coroutines.JobSupport.cancel(JobSupport.kt:1579)
    at kotlinx.coroutines.CoroutineScopeKt.cancel(CoroutineScope.kt:217)
    at kotlinx.coroutines.CoroutineScopeKt.cancel$default(CoroutineScope.kt:215)
    at com.example.coroutinerevise.CoroutineExperiment$testingAsync$1.invokeSuspend(CoroutineExperiment.kt:241)
    at |b|b|b(Coroutine boundary.|b(|b)
    at kotlinx.coroutines.DeferredCoroutine.await$suspendImpl(Builders.common.kt:101)
    at com.example.coroutinerevise.CoroutineExperiment$testingAsync$1.invokeSuspend(CoroutineExperiment.kt:254)
Caused by: kotlinx.coroutines.JobCancellationException: Job was cancelled; job=SupervisorJobImpl{Cancelled}@39529185
    at kotlinx.coroutines.JobSupport.cancel(JobSupport.kt:1579)
    at kotlinx.coroutines.CoroutineScopeKt.cancel(CoroutineScope.kt:217)
    at kotlinx.coroutines.CoroutineScopeKt.cancel$default(CoroutineScope.kt:215)
    at com.example.coroutinerevise.CoroutineExperiment$testingAsync$1.invokeSuspend(CoroutineExperiment.kt:241)
    at kotlin.coroutines.jvm.internal.BaseContinuationImpl.resumeWith(ContinuationImpl.kt:33)

Is it true, a canceled coroutine scope cannot be used for launch or async anymore?

kotlin-coroutines kotlin
4 Answers

Instead of using CoroutineScope for cancelling all of the launched jobs in it, you may want to use the underlying CoroutineContext with its cancelChildren() method which doesn't affect the Job state (which is not true for plain cancel() method) and allows to continue launching new coroutines after being invoked.

user_18554520

Following up on @Alex Bonel response.

For example you have a method like

fun doApiCall() {
 viewModelScope.launch { 
     // do api call here
 }
}

You can call doApiCall() again and again

viewModelScope.coroutineContext.cancelChildren()
doApiCall()

Calling doApiCall() will not have any effect.

viewModelScope.coroutineContext.cancel()
doApiCall() // would not call
user_44203550

I am using that in compose and it is slightly different.

  1. Define coroutine scope in compose

val coroutineScope = rememberCoroutineScope()

  1. Launch coroutine

coroutineScope.launch(Dispatchers.Main) { //Perform your operation }

  1. Cancel all coroutines that belong to coroutineScope

coroutineScope.coroutineContext.cancelChildren()

user_39850710

Related to lifecycleScope comment above, I'm not sure how common cancellation like this would be in practice? fwiw something like following will work:

val scope = MainScope()
runBlocking {
    val job1 = scope.launch {
        try {
            println("Start Launch 1")
            delay(200)
            println("End Launch 1")
        } catch (e: CancellationException) {
            println("Cancellation Exception")
        }
    }

    job1.cancel()
    val job2 = scope.launch {
        try {
            println("Start Launch 2")
            delay(200)
            println("End Launch 2")
        } catch (e: CancellationException) {
            println("Cancellation Exception")
        }
    }
    job2.join()

    println("Finished")
}

This particular example will print

Start Launch 1
Cancellation Exception
Start Launch 2
End Launch 2
Finished
user_7938610
Related