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.

2022 - Android Advocate of the Year

2022 - HackerNoon Contributor of the Year - Firebase

2022 - HackerNoon Contributor of the Year - Kotlin

2022 - HackerNoon Contributor of the Year - Performance

Nominated for 2022 - Android Advocate of the Year

Nominated for 2022 - HackerNoon Contributor of the Year - Performance

Nominated for 2022 - HackerNoon Contributor of the Year - Firebase

Nominated for 2022 - HackerNoon Contributor of the Year - Kotlin

Too Long; Didn't Read

In your car, at home, or at work — Bosch technology shapes many areas of life.

Cancelling Coroutines in Kotlin

Cancelling Coroutines in Kotlin

Too Long; Didn't Read

Timofey Krestyanov

About Author

TOPICS

THIS ARTICLE WAS FEATURED IN...

Cancelling Coroutines in Kotlin

Too Long; Didn't Read

Timofey Krestyanov

About Author

TOPICS

THIS ARTICLE WAS FEATURED IN...

RELATED STORIES