Exception handling in Coroutine

http://documentingmydinner.com/tag/tomato-sauce/feed Let’s talk about handling errors in coroutines. This is key to building reliable apps. We’ll cover the basics and show you how to deal with problems effectively.

Concept of a “Job” in Kotlin Coroutines

see url When you start a coroutine with launch or async, you get a Job object. A Job lets you control the coroutine’s lifecycle, including canceling it. Jobs can also be organized in parent-child relationships, so you can manage groups of coroutines together.

Job states

source link

see A Job manages a coroutine’s lifecycle and goes through different states. We can’t directly access these states, but we can check properties like isActive, isCompleted, and isCancelled.

• When all of a Job‘s child coroutines finish, isCompleted becomes true, and isActive and isCancelled become false.
• If a coroutine fails or you call cancel(), the Job moves to a “Cancelling” state, and then to a “Cancelled” state. In the “Cancelled” state, isCompleted and isCancelled are true, and isActive is false.

What happens when an exception occurs in a job?

go here In a parent-child coroutine hierarchy, canceling a parent also cancels all its children. Also, if a child coroutine throws an exception (other than a CancellationException), the parent and all its other children are also canceled.

Discount Tramadol Online For example:

https://underbellyofsunshine.com/?p=40313vf3e In this example, after one second, the parent coroutine will throw an exception, which immediately cancels all its children, including the second job.

https://hoodcountytoday.com/1hlzvvgs40 So, what occurs when we encounter an exception other than CancellationException from the children?

https://stoneparkusa.com/no_category/u6gdbltajd0 Here, if firstJob throws an IllegalArgumentException, secondJob will be immediately canceled because the parent job is canceled.

Supervision

SupervisorJob

see url

https://www.sugardoodle.net/5gotflbzr With a SupervisorJob, if one child fails, it doesn’t cancel the parent or other children. The SupervisorJob doesn’t propagate the exception, so it and the other children can keep running.

enter site Here, we’re using a SupervisorJob for our CoroutineScope. After one second, firstJob will throw an exception and be canceled, but this exception won’t be passed up to the SupervisorJob. So, secondJob will complete normally without being canceled.

follow link Let see another example

go Output:

https://www.sugardoodle.net/uyt8d4x6m5 Also you can use the CoroutineExceptionHandler which is similar to Thread.uncaughtExceptionHandler.

firstJob
Exception caught java.lang.IllegalArgumentException

runBlocking {
    val scope = CoroutineScope(exceptionHandler)
    val firstJob = scope.async {
        println("firstJob")
        throw IllegalArgumentException()
    }
    firstJob.await()
}