Photo by Mike Lewis HeadSmart Media on Unsplash

This is the third in a series of blog posts about applying Structural concurrency.

fun main() {   
    try {
        throw (Exception())
    } catch (e: Exception) {
        println(e.javaClass.canonicalName)
    }
}

fun main() {   
    try {
        funException()
    } catch (e: Exception){
        println(e.javaClass.canonicalName)
    }
}

fun funException(){
    throw (Exception())
}

Different coroutine builders and suspend functions have differences in their behaviour. Let’s discuss them.

Top-level launch or launch in supervisorScope

Exception thrown here and not caught by try/catch inside launch OR propagated from child leads to:

1. cancelling other siblings
2. cancelling itself
3. propagating up the Job hierarchy

These exceptions can’t be caught outside launch using try/catch because they will not be re-thrown via callstack but will be propagated via Job hierarchy.

import kotlinx.coroutines.*

fun main() {   
  val scope = CoroutineScope(Job())
    try {
        scope.launch {
            throw (Exception())
        }
    } catch (e: Exception) {
        println(e.javaClass.canonicalName)
    }
    Thread.sleep(1000)
}

Exception can be handled on top of Job hierarchy by installed CoroutineExceptionHandler or by inherited CoroutineExceptionHandler.

import kotlinx.coroutines.*

fun main() {   
    val ceh = CoroutineExceptionHandler { context, exception ->
        println("CEH: $exception")
    }
    val scope = CoroutineScope(Job() + ceh)
    
    scope.launch {
        throw (Exception())
    }
    Thread.sleep(1000)
}

If CoroutineExceptionHandler is missing — the exception is passed to the thread’s uncaught exception handler. On Android, it will lead to application crash.

Top-level async or async in supervisorScope

Exception thrown here and not caught by try/catch inside async OR propagated from a child will be encapsulated in Deferred object returned by the builder.

It is thrown as a normal exception only when invoking the await() method. Therefore — await() surrounded by try/catch should be used to avoid crash.

import kotlinx.coroutines.*

fun main() {   
val scope = CoroutineScope(Job())
var deferred: Deferred<Unit>? = null

    scope.launch {
        supervisorScope {
            deferred = async {
                throw (Exception())
            }
        }

        supervisorScope {
            try {
                deferred?.await()
            } catch (e: Exception) {
                println(e.javaClass.canonicalName)
            }
        }
    }
    Thread.sleep(1000)
}

Without await() you can’t catch an exception in async surrounding by try/catch — so exception will be silently dropped.

import kotlinx.coroutines.*

fun main() {   
    val scope = CoroutineScope(Job())

    scope.async {
        throw (Exception())
    }
    Thread.sleep(1000)
}

CoroutineExceptionHandler has no effect here because there is no propagation via Job hierarchy.

Nested launch

Uncaught exception in launchOR exception propagated from child leads to:

1. cancelling other children
2. cancelling itself
3. propagating up the Job hierarchy

These exceptions are not re-thrown but propagate up the Job hierarchy. If nested launch() is wrapped with try/catch then exception can’t be caught.

Nested async

Uncaught exception propagated from child OR occurred in async leads to:

1. cancelling other children
2. cancelling itself
3. propagating up the Job hierarchy

Exception propagates up the Job hierarchy even without calling await() on it.

If await() is wrapped with try/catch then exception can be caught but it ANYWAY propagates via Job hierarchy.

coroutineScope

Uncaught exception in scoping function coroutineScopeOR exception propagated from child leads to:

1. cancelling other children
2. cancelling itself
3. it doesn’t propagate exception up the Job hierarchy

Exception will be re-thrown, it allows to handle exception of failed coroutineScope surrounded by try/catch.

import kotlinx.coroutines.*

fun main() {   
    val scope = CoroutineScope(Job())

    scope.launch {
        try {
            coroutineScope {
                throw (Exception())
            }
        } catch (e: Exception) {
            println(e.javaClass.canonicalName)
        }
    }
    Thread.sleep(1000)
}

supervisorScope (exception thrown in scope)

Uncaught exception in scoping function supervisorScope (exception thrown in the block) leads to:

1. cancelling other children
2. cancelling itself
3. it doesn’t propagate exceptions up the Job hierarchy.

Exception will be re-thrown which allows us to handle it by surrounding supervisorScope with try/catch.

import kotlinx.coroutines.*

fun main() {   
    val scope = CoroutineScope(Job())

    scope.launch {
        try {
            supervisorScope {
                //child
                launch {
                    delay(50)
                    println("sibling")
                }

                throw (Exception())
            }
        } catch (e: Exception) {
            println(e.javaClass.canonicalName)
        }
    }    
    Thread.sleep(1000)
}

supervisorScope (exception thrown in child coroutine)

If one of the child coroutines fails:

1. the sibling coroutines are not cancelled
2. supervisorScope is not cancelled
3. no exception propagation up the Job hierarchy
4. no re-throw exceptions

This article was previously published on proandroiddev.com