协程中的异常处理Parent-Child关系

如果一个coroutine抛出了异常, 它将会把这个exception向上抛给它的parent, 它的parent会做以下三件事情:

取消其他所有的children.取消自己.把exception继续向上传递.

这是默认的异常处理关系, 取消是双向的, child会取消parent, parent会取消所有child.

(相关资料图)

catch不住的exception

看这个代码片段:

fun main() {    val scope = CoroutineScope(Job())    try {        scope.launch {            throw RuntimeException()        }    } catch (e: Exception) {        println("Caught: $e")    }    Thread.sleep(100)}

这里的异常catch不住了.会直接让main函数的主进程崩掉.

这是因为和普通的异常处理机制不同, coroutine中未被处理的异常并不是直接抛出, 而是按照job hierarchy向上传递给parent.

如果把try放在launch里面还行.

默认的异常处理

默认情况下, child发生异常, parent和其他child也会被取消.

fun main() {    println("start")    val exceptionHandler = CoroutineExceptionHandler { _, exception ->        println("CoroutineExceptionHandler got $exception")    }    val scope = CoroutineScope(Job() + exceptionHandler)    scope.launch {        println("child 1")        delay(1000)        println("finish child 1")    }.invokeOnCompletion { throwable ->        if (throwable is CancellationException) {            println("Coroutine 1 got cancelled!")        }    }    scope.launch {        println("child 2")        delay(100)        println("child 2 throws exception")        throw RuntimeException()    }    Thread.sleep(2000)    println("end")}

打印出:

startchild 1child 2child 2 throws exceptionCoroutine 1 got cancelled!CoroutineExceptionHandler got java.lang.RuntimeExceptionend

SupervisorJob

如果有一些情形, 开启了多个child job, 但是却不想因为其中一个的失败而取消其他, 怎么办? 用SupervisorJob.

比如:

val uiScope = CoroutineScope(SupervisorJob())

如果你用的是scope builder, 那么用supervisorScope.

用SupervisorJob改造上面的例子:

fun main() {    println("start")    val exceptionHandler = CoroutineExceptionHandler { _, exception ->        println("CoroutineExceptionHandler got $exception")    }    val scope = CoroutineScope(SupervisorJob() + exceptionHandler)    scope.launch {        println("child 1")        delay(1000)        println("finish child 1")    }.invokeOnCompletion { throwable ->        if (throwable is CancellationException) {            println("Coroutine 1 got cancelled!")        }    }    scope.launch {        println("child 2")        delay(100)        println("child 2 throws exception")        throw RuntimeException()    }    Thread.sleep(2000)    println("end")}

输出:

startchild 1child 2child 2 throws exceptionCoroutineExceptionHandler got java.lang.RuntimeExceptionfinish child 1end

尽管coroutine 2抛出了异常, 另一个coroutine还是做完了自己的工作.

SupervisorJob的特点

SupervisorJob把取消变成了单向的, 只能从上到下传递, 只能parent取消child, 反之不能取消.这样既顾及到了由于生命周期的结束而需要的正常取消, 又避免了由于单个的child失败而取消所有.

viewModelScope的context就是用了SupervisorJob() + Dispatchers.Main.immediate.

除了把取消变为单向的, supervisorScope也会和coroutineScope一样等待所有child执行结束.

在supervisorScope中直接启动的coroutine是顶级coroutine.顶级coroutine的特性:

可以加exception handler.自己处理exception.比如上面的例子中coroutine child 2可以直接加exception handler.

使用注意事项, SupervisorJob只有两种写法:

作为CoroutineScope的参数传入: CoroutineScope(SupervisorJob()).使用supervisorScope方法.

把Job作为coroutine builder(比如launch)的参数传入是错误的做法, 不起作用, 因为一个新的coroutine总会assign一个新的Job.

异常处理的办法try-catch

和普通的异常处理一样, 我们可以用try-catch, 只是注意要在coroutine里面:

fun main() {    val scope = CoroutineScope(Job())    scope.launch {        try {            throw RuntimeException()        } catch (e: Exception) {            println("Caught: $e")        }    }    Thread.sleep(100)}

这样就能打印出:

Caught: java.lang.RuntimeException

对于launch, try要包住整块.对于async, try要包住await语句.

scope function: coroutineScope()

coroutineScope会把其中未处理的exception抛出来.

相比较于这段代码中catch不到的exception:

fun main() {    val scope = CoroutineScope(Job())    scope.launch {        try {            launch {                throw RuntimeException()            }        } catch (e: Exception) {            println("Caught: $e")        }    }    Thread.sleep(100)}

没走到catch里, 仍然是主进程崩溃.

这个exception是可以catch到的:

fun main() {    val scope = CoroutineScope(Job())    scope.launch {        try {            coroutineScope {                launch {                    throw RuntimeException()                }            }        } catch (e: Exception) {            println("Caught: $e")        }    }    Thread.sleep(100)}

打印出:

Caught: java.lang.RuntimeException

因为这里coroutineScope把异常又重新抛出来了.

注意这里换成supervisorScope可是不行的.

CoroutineExceptionHandler

CoroutineExceptionHandler是异常处理的最后一个机制, 此时coroutine已经结束了, 在这里的处理通常是报告log, 展示错误等.如果不加exception handler那么unhandled exception会进一步往外抛, 如果最后都没人处理, 那么可能造成进程崩溃.

CoroutineExceptionHandler需要加在root coroutine上.

这是因为child coroutines会把异常处理代理到它们的parent, 后者继续代理到自己的parent, 一直到root.所以对于非root的coroutine来说, 即便指定了CoroutineExceptionHandler也没有用, 因为异常不会传到它.

两个例外:

async的异常在Deferred对象中, CoroutineExceptionHandler也没有任何作用.supervision scope下的coroutine不会向上传递exception, 所以CoroutineExceptionHandler不用加在root上, 每个coroutine都可以加, 单独处理.

通过这个例子可以看出另一个特性: CoroutineExceptionHandler只有当所有child都结束之后才会处理异常信息.

@OptIn(DelicateCoroutinesApi::class)fun main() = runBlocking {    val handler = CoroutineExceptionHandler { _, exception ->         println("CoroutineExceptionHandler got $exception")     }    val job = GlobalScope.launch(handler) {        launch { // the first child            try {                delay(Long.MAX_VALUE)            } finally {                withContext(NonCancellable) {                    println("Children are cancelled, but exception is not handled until all children terminate")                    delay(100)                    println("The first child finished its non cancellable block")                }            }        }        launch { // the second child            delay(10)            println("Second child throws an exception")            throw ArithmeticException()        }    }    job.join()}

输出:

Second child throws an exceptionChildren are cancelled, but exception is not handled until all children terminateThe first child finished its non cancellable blockCoroutineExceptionHandler got java.lang.ArithmeticException

如果多个child都抛出异常, 只有第一个被handler处理, 其他都在exception.suppressed字段里.

fun main() = runBlocking {    val handler = CoroutineExceptionHandler { _, exception ->        println("CoroutineExceptionHandler got $exception with suppressed ${exception.suppressed.contentToString()}")    }    val job = GlobalScope.launch(handler) {        launch {            try {                delay(Long.MAX_VALUE) // it gets cancelled when another sibling fails with IOException            } finally {                throw ArithmeticException() // the second exception            }        }        launch {            delay(100)            throw IOException() // the first exception        }        delay(Long.MAX_VALUE)    }    job.join()}

输出:

CoroutineExceptionHandler got java.io.IOException with suppressed [java.lang.ArithmeticException]

单独说一下async

async比较特殊:

作为top coroutine时, 在await的时候try-catch异常.如果是非top coroutine, async块里的异常会被立即抛出.

例子:

fun main() {    val scope = CoroutineScope(SupervisorJob())    val deferred = scope.async {        throw RuntimeException("RuntimeException in async coroutine")    }    scope.launch {        try {            deferred.await()        } catch (e: Exception) {            println("Caught: $e")        }    }    Thread.sleep(100)}

这里由于用了SupervisorJob, 所以async是top coroutine.

fun main() {    val coroutineExceptionHandler = CoroutineExceptionHandler { coroutineContext, exception ->        println("Handle $exception in CoroutineExceptionHandler")    }    val topLevelScope = CoroutineScope(SupervisorJob() + coroutineExceptionHandler)    topLevelScope.launch {        async {            throw RuntimeException("RuntimeException in async coroutine")        }    }    Thread.sleep(100)}

当它不是top coroutine时, 异常会被直接抛出.

特殊的CancellationException

CancellationException是特殊的exception, 会被异常处理机制忽略, 即便抛出也不会向上传递, 所以不会取消它的parent.但是CancellationException不能被catch, 如果它不被抛出, 其实协程没有被成功cancel, 还会继续执行.

CancellationException的透明特性:如果CancellationException是由内部的其他异常引起的, 它会向上传递, 并且把原始的那个异常传递上去.

@OptIn(DelicateCoroutinesApi::class)fun main() = runBlocking {    val handler = CoroutineExceptionHandler { _, exception ->        println("CoroutineExceptionHandler got $exception")    }    val job = GlobalScope.launch(handler) {        val inner = launch { // all this stack of coroutines will get cancelled            launch {                launch {                    throw IOException() // the original exception                }            }        }        try {            inner.join()        } catch (e: CancellationException) {            println("Rethrowing CancellationException with original cause")            throw e // cancellation exception is rethrown, yet the original IOException gets to the handler        }    }    job.join()}

输出:

Rethrowing CancellationException with original causeCoroutineExceptionHandler got java.io.IOException

这里Handler拿到的是最原始的IOException.

Further Reading

官方文档:

Coroutine exceptions handling

Android官方文档上链接的博客和视频:

Exceptions in coroutinesKotlinConf 2019: Coroutines! Gotta catch "em all! by Florina Muntenescu & Manuel Vivo

其他:

Kotlin Coroutines and Flow - Use Cases on AndroidWhy exception handling with Kotlin Coroutines is so hard and how to successfully master it!

关键词：