Overview Sometimes we need to close some thread, and we can't just kill the thread as we need to free resources and close connections. Coroutines provide a simple undo mechanism to solve such problems and problems with long-running operations or memory leaks. Cancelling Jobs Let's create an object using the factory function: Job() suspend fun main() = coroutineScope {
    val job = Job()
} This Job object represents a running coroutine. Coroutines whose results we don't need can cancel anytime we want by calling the function: job.cancel() suspend fun main() = coroutineScope {
    val job = Job()
    launch(job) {
        repeat(1000) { i ->
           delay(50)
           println("$i")
      }
   }
   job.cancel()
} The coroutine will be canceled without waiting for its actual completion. Calling cancel again does nothing. The cancellation of a coroutine is fully thread-safe and non-blocking. If we need to wait for the Job to be complete, we can use the : job.join() suspend fun main() = coroutineScope {
    val job = Job()
    launch(job) {
        repeat(1000) { i ->
           delay(50)
           println("$i")
      }
   }
   delay(500)
   job.cancel()
   job.join()
   println("Cancelled")
} We can also combine these two calls into the function. job.cancelAndJoin() Exception handling If the job is canceled, a will be thrown. We can catch it with try-catch-finally: CancellationException suspend fun main() = coroutineScope {
    val job = Job()
    launch(job) {
       try {
            repeat(1000) { i ->
                delay(50)
                println("$i")
            }
        } catch (e: CancellationException) {
            println(e)
        } finally {
            println("Finally")
        }
    }
    delay(500)
    job.cancelAndJoin()
    println("Cancelled")
} is a special exception to handle coroutine execution cancellation. СancelationException We can define behavior for all unhandled exceptions that occur in the current coroutine execution context. To do this, you can use , which is an interceptor for any exception. CoroutineExceptionHandler CoroutineExceptionHandler { coroutineContext, throwable ->
    println(throwable)
} We can catch an exception this way from any thread and define default behavior for all of them. is called last after an error has occurred. CoroutineExceptionHandler Conclusion Cancellation in coroutines is easy to use and is important for the performance of your application. We can use cancellation in coroutines for easy resource cleaning or possibly some form of error logging.

Jetpack DataStore in Android Explained

Nominated for 2022 - Android Advocate of the Year

Cancelling Coroutines in Kotlin

About Author

Comments

TOPICS

THIS ARTICLE WAS FEATURED IN

Related Stories

Untitled Story

How to Create an Android Library

Learning the Fundamentals of Coroutines: Part 1

How Coroutines Enable Cooperative Multitasking and Concurrency

10 Must Have Chrome Extensions for a Web Developer

The Noonification: Can Mankind Survive as an Interplanetary Species? (10/20/2022)

How to Create an Android Library

Learning the Fundamentals of Coroutines: Part 1

How Coroutines Enable Cooperative Multitasking and Concurrency

10 Must Have Chrome Extensions for a Web Developer

The Noonification: Can Mankind Survive as an Interplanetary Species? (10/20/2022)

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps