Note: We can also use cancelAndJoin extension function that combines cancel and join invocations.

Coroutine Cancellation Challenges During Computation

All the suspend functions inside a coroutine are cancellable. They check for cancellation of coroutine and throw CancellationException when cancelled. However, if a coroutine is working on a computation, it will not check for cancellation, hence can not be cancelled. Let’s see an example for the same:

fun nonCancellableCoroutine() = runBlocking {
    var sum = 0
    val job = launch(Dispatchers.Default) {
        for (i in 1..1000) {
            sum += i
            println("Partial sum after $i iterations: $sum")
        }
    }
    delay(500)
    println("I'm tired of waiting!")
    job.cancelAndJoin()
    println("Now I can quit.")
}

When you run this code, you will see that even after you call cancelAndJoin() , it continues to print until it completes it’s 1000 iterations.

Now, let’s add a delay after each iteration of the loop and see what happens

fun cancellableCoroutineWithSuspendFunction() = runBlocking {
    var sum = 0
    val job = launch(Dispatchers.Default) {
        for (i in 1..1000) {
            sum += i
            println("Partial sum after $i iterations: $sum")
            delay(500)
        }
    }
    println("I'm tired of waiting!")
    job.cancelAndJoin()
    println("Now I can quit.")
}

When I add a delay in the loop, the loop get’s cancelled before completing because delay is a suspend function and as I mentioned above all suspend functions are cancellable.

Now, let’s try and catch the Exception here:

fun catchExceptionInACoroutineWithSuspendFunction() = runBlocking {
    var sum = 0
    val job = launch(Dispatchers.Default) {
        for (i in 1..1000) {
            try {
                sum += i
                println("Partial sum after $i iterations: $sum")
                delay(500)
            } catch (e: Exception) {
                println(e)
            }
        }
    }
    println("I'm tired of waiting!")
    job.cancelAndJoin()
    println("Now I can quit.")
}

The delay function checks for cancellation and throws a CancellationException which we have catched and handled in our code. That is why the loop completes this time.

fun cancelCoroutineWithYield() = runBlocking {
    var sum = 0
    val job = launch(Dispatchers.Default) {
        for (i in 1..1000) {
            yield()
            sum += i
            println("Partial sum after $i iterations: $sum")
        }
    }
    println("I'm tired of waiting!")
    job.cancelAndJoin()
    println("Now I can quit.")
}

When the coroutine is canceled using job.cancelAndJoin() after a delay, the catch block is executed, catching the CancellationException. The finally block is also executed, demonstrating that finalisation actions can be performed even during cancellation.

Use function

use function is an extension function on Closeable resources in Kotlin. It is used to manage resources such as files, network connections or any other resource that implements the Closeable interface. It will ensure that the resource is properly closed, just like try-catch-finally block, after the function has been completed, whether any exception was raised or not.

fun closeResourcesUsingUse() = runBlocking {
    val job = launch {
        try {
            val lines = readFileAsync("example.txt")
            lines.forEach { println(it) }
        } catch (e: Exception) {
            println("Error reading file: $e")
        }
    }
    delay(1000)
        job.cancelAndJoin()
        println("Job cancelled and joined.")
   }

suspend fun readFileAsync(filename: String): List<String> = coroutineScope {
    return@coroutineScope withContext(Dispatchers.Default) {
        withContext(Dispatchers.IO) {
            BufferedReader(FileReader(filename)).use { reader ->
                val lines = mutableListOf<String>()
                var line: String? = reader.readLine()
                while (line != null) {
                    lines.add(line)
                    line = reader.readLine()
                }
                lines
            }
        }
    }
}

The BufferedReader is wrapped in the use function, ensuring that it is properly closed after the lines are read.

Run non-cancellable block

If we try to call a suspend function in the finally block of the above example, we will get a CancellationException because the coroutine running this code is cancelled.

Usually, we will not find any need to call a suspend function in the finally block because all well-behaving closing operations like closing a file, closing any communication channel or cancelling a job are non-blocking and do not involve any suspending functions.

However if we ever find a need to call suspend function in the finally block, we can do so by wrapping our code inside withContext(NonCancellable) block like this:

fun runNonCancellableBlock() = runBlocking{
    val job = launch {
        try {
            repeat(1000) { i ->
                println("job: I'm sleeping $i ...")
                delay(500L)
            }
        } finally {
            withContext(NonCancellable) {
                println("job: I'm running finally")
                delay(1000L)
                println("job: And I've just delayed for 1 sec because I'm non-cancellable")
            }
        }
    }
    delay(1300L) // delay a bit
    println("main: I'm tired of waiting!")
    job.cancelAndJoin() // cancels the job and waits for its completion
    println("main: Now I can quit.")
}

The NonCancellable context is a context in which the coroutine is not cancellable. This means even if the cancellation is requested, the coroutine will continue executing the code within this context. After the NonCancellable block finishes, the cancellation state will restore.