Kotlin协程之异常处理（launch和async的异常处理机制详解）

最新推荐文章于 2025-05-22 13:51:12 发布
最新推荐文章于 2025-05-22 13:51:12 发布
阅读量943 收藏 21
点赞数 5
CC 4.0 BY-SA版权
文章标签： kotlin android 协程 launch async 异常处理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Chenyile161616/article/details/147258494

一 异常传播机制

  1. 先将异常传递给子协程，取消其所有子线程；（取消级联）

  2. 而后取消自身；

  3. 再将异常传递给父协程，父协程接收到异常后，会取消其下所有子协程之后取消自身，再向上传递，直到到达最顶层协程。（异常的向上传递）

二 异常处理机制

（1）try-catch

        在kotlin协程中，try-catch的使用是有限制的，不是任何情况都能生效的，例如在launch或async外使用try-catch进行包装，是捕获不到异常的！

一般在协程内部或挂起函数外部（包裹挂起函数）使用

（2）CoroutineExceptionHandler（官方推荐的协程异常处理）

        CoroutineExceptionHandler用于捕获未处理的异常，可以在协程作用域创建时或协程启动时作为上下文传入。

三 不同协程构建器启动的协程的默认异常处理

下面讨论的，都是不进行任何异常处理和特殊操作的情况！

（1）launch启动的协程

launch启动的协程遇到异常时，默认情况下会直接抛出。

最终导致协程所在的协程树都收到影响，即同级协程、子协程、和父级协程都收到影响。

（2）async启动的协程

①分为两种情况：异常不一定会抛出，可能被丢弃

  • async作为根协程，即没有父协程：

    遇到异常时，依赖用户消费。

    • 情况1：用户不调用await()，则异常被丢弃，不会抛出。

    • 情况2：用户调用await()，则异常直接在await()处抛出。

  • async作为子协程，即有父协程：

    遇到异常时，不依赖用户消费。

    • 情况3：用户不调用await()，根据异常传播机制，会传递给其子协程后取消自己，再将异常传递给父协程，自下而上由各级父协程决定如何进行异常处理，若父协程是launch启动的且没有进行异常处理，则异常会直接在父协程处抛出；若父协程是async启动的，则返回①继续判断...

    • 情况4：用户调用await()，异常会先向上传递，再在await()调用处抛出，故即使在await()调用处进行异常捕获，也无法阻止异常继续向上传递（若想避免这种情况，可以使用SupervisorJob上下文 或 supervisorScope 限制异常的向上传递），即异常还是会传递到父协程，若父协程是launch启动的且没有进行异常处理，则程序会抛出异常；若父协程是async启动的，则返回①继续判断...

（3）上述各情况示例代码及运行结果：

情况1：
@Test
    fun coroutineExceptionTest5(): Unit = runBlocking {
        val deferred = GlobalScope.async {
            println("父async协程")
            async {
                delay(200)
                println("子async协程")

            }
            throw Exception("父async协程 异常")

        }

        delay(400)
 
    }

//运行结果
父async协程
情况2：
@Test
    fun coroutineExceptionTest5(): Unit = runBlocking {
        val deferred = GlobalScope.async {
            println("父async协程")
            async {
                delay(200)
                println("子async协程")

            }
            throw Exception("父async协程 异常")

        }

        delay(400)
        //调用await()方法
        deferred.await()
    }

//运行结果
父async协程

父async协程 异常
java.lang.Exception: 父async协程 异常
	at com.yl.activitylifecycletest.CoroutineExceptionTest$coroutineExceptionTest5$1$deferred$1.invokeSuspend(CoroutineExceptionTest.kt:122)...
情况3：
父协程是launch启动的
 @Test
    fun coroutineExceptionTest7(): Unit = runBlocking {
        GlobalScope.launch {
            println("父launch协程")
            async {
                delay(200)
                println("子async协程")
                throw Exception("子async协程 异常")
            }
            //不调用await()
        }
        delay(400)
    }

//运行结果：由于父协程是launch且没有进行异常处理，故直接抛出异常
父launch协程
子async协程
Exception in thread "DefaultDispatcher-worker-1 @coroutine#3" java.lang.Exception: 子async协程 异常
	at com.yl.activitylifecycletest.CoroutineExceptionTest$coroutineExceptionTest7$1$1$1.invokeSuspend(CoroutineExceptionTest.kt:152)
	at kotlin.coroutines.jvm.internal.BaseContinuationImpl.resumeWith(ContinuationImpl.kt:33)
	at kotlinx.coroutines.DispatchedTask.run(DispatchedTask.kt:106)
	at kotlinx.coroutines.scheduling.CoroutineScheduler.runSafely(CoroutineScheduler.kt:570)
	at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.executeTask(CoroutineScheduler.kt:749)
	at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.runWorker(CoroutineScheduler.kt:677)
	at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.run(CoroutineScheduler.kt:664)
	Suppressed: kotlinx.coroutines.DiagnosticCoroutineContextException: [CoroutineId(2), "coroutine#2":StandaloneCoroutine{Cancelling}@735d482b, Dispatchers.Default]
父协程是async启动的
 @Test
    fun coroutineExceptionTest6(): Unit = runBlocking {
        GlobalScope.async {
            println("父async协程")
            async {
                delay(200)
                println("子async协程")
                throw Exception("子async协程 异常")
            }
            //不调用await()
        }
        delay(400)
    }

//运行结果：由于父协程是async是根协程，且没有调用await，故异常被丢弃，不抛出
父async协程
子async协程
情况4：
父协程是launch启动的
在await()调用处不进行try-catch进行异常捕获
@Test
    fun coroutineExceptionTest8(): Unit = runBlocking {
        GlobalScope.launch {
            println("父launch协程")
            val deferred = async {
                delay(200)
                println("子async协程")
                throw Exception("子async协程 异常")
            }
            //调用await()
            deferred.await()
        }
        delay(400)
    }

//运行结果：调用await()，异常直接在await()调用处抛出
父launch协程
子async协程
Exception in thread "DefaultDispatcher-worker-1 @coroutine#2" java.lang.Exception: 子async协程 异常
	at com.yl.activitylifecycletest.CoroutineExceptionTest$coroutineExceptionTest8$1$1$deferred$1.invokeSuspend(CoroutineExceptionTest.kt:166)
	at kotlin.coroutines.jvm.internal.BaseContinuationImpl.resumeWith(ContinuationImpl.kt:33)
使用try-catch在await()调用处进行异常捕获，异常也还是会向上传递
@Test
    fun coroutineExceptionTest8(): Unit = runBlocking {
        GlobalScope.launch(/*CoroutineExceptionHandler(){_,t->
            println("CoroutineExceptionHandler 捕获异常 $t")
        }*/) {
            println("父launch协程")
            val deferred = async {
                delay(200)
                println("子async协程")
                throw Exception("子async协程 异常")
            }
            //调用await()，并使用try-catch进行异常捕获
            try {
                deferred.await()
            }catch (e:Exception){
                println("try catch 捕获异常 $e")
            }
        }
        delay(400)
    }


//运行结果：由于异常是先向上传递再在await调用处抛出的，
//故即使try-catch捕获到了异常，但是异常还是向上传递到父协程，
//又因为父协程是launch启动的，且没有进行异常处理，故而异常还是抛出

父launch协程
子async协程
try catch 捕获异常 java.lang.Exception: 子async协程 异常
Exception in thread "DefaultDispatcher-worker-1 @coroutine#2" java.lang.Exception: 子async协程 异常
	at com.yl.activitylifecycletest.CoroutineExceptionTest$coroutineExceptionTest8$1$1$deferred$1.invokeSuspend(CoroutineExceptionTest.kt:168)
	at kotlin.coroutines.jvm.internal.BaseContinuationImpl.resumeWith(ContinuationImpl.kt:33)
	at kotlinx.coroutines.DispatchedTask.run(DispatchedTask.kt:106)
	at kotlinx.coroutines.scheduling.CoroutineScheduler.runSafely(CoroutineScheduler.kt:570)
	at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.executeTask(CoroutineScheduler.kt:749)
	at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.runWorker(CoroutineScheduler.kt:677)
	at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.run(CoroutineScheduler.kt:664)
	Suppressed: kotlinx.coroutines.DiagnosticCoroutineContextException: [CoroutineId(2), "coroutine#2":StandaloneCoroutine{Cancelling}@6e8881d6, Dispatchers.Default]
在父协程中进行异常处理，捕获未处理的异常，异常不会抛出
 @Test
    fun coroutineExceptionTest8(): Unit = runBlocking {
        GlobalScope.launch(CoroutineExceptionHandler() { _, t ->
            println("CoroutineExceptionHandler 捕获异常 $t")
        }) {
            println("父launch协程")
            val deferred = async {
                delay(200)
                println("子async协程")
                throw Exception("子async协程 异常")
            }
            //调用await()，并使用try-catch进行异常捕获
            try {
                deferred.await()
            } catch (e: Exception) {
                println("try catch 捕获异常 $e")
            }
        }
        delay(400)
    }

//运行结果：在父协程进行了异常处理，异常被父协程成功捕获拦截，不会抛出
父launch协程
子async协程
try catch 捕获异常 java.lang.Exception: 子async协程 异常
CoroutineExceptionHandler 捕获异常 java.lang.Exception: 子async协程 异常
 使用supervisorScope限制异常的向上传递，异常不会传递到父协程抛出
@Test
    fun coroutineExceptionTest8(): Unit = runBlocking {
        GlobalScope.launch(/*CoroutineExceptionHandler() { _, t ->
            println("CoroutineExceptionHandler 捕获异常 $t")
        }*/) {
            println("父launch协程")
            //使用supervisorScope 限制异常向上传递
            supervisorScope {
                val deferred = async {
                    delay(200)
                    println("子async协程")
                    throw Exception("子async协程 异常")
                }
                //调用await()，并使用try-catch进行异常捕获
                try {
                    deferred.await()
                } catch (e: Exception) {
                    println("try catch 捕获异常 $e")
                }
            }


        }
        delay(400)
    }

//运行结果：异常没有向上传递到父launch协程抛出

父launch协程
子async协程
try catch 捕获异常 java.lang.Exception: 子async协程 异常
父协程是async启动的
调用子async协程的await()，并对其进行try-catch异常捕获
 @Test
    fun coroutineExceptionTest9(): Unit = runBlocking {
        GlobalScope.async() {
            println("父async协程")
            val deferred = async {
                delay(200)
                println("子async协程")
                throw Exception("子async协程 异常")
            }
            //调用await()
            try {
                deferred.await()
            }catch (e:Exception){
                println("try-catch 捕获异常 $e")
            }
        }
        delay(2000)
    }

//运行结果：此处我们使用try-catch对await()进行包装，捕获到了其抛出的异常，
//由于父协程并没有调用await()，故异常不会抛出导致应用崩溃。
父async协程
子async协程
try-catch 捕获异常 java.lang.Exception: 子async协程 异常
调用子async协程的await()，但不对其进行try-catch异常捕获，也不会导致应用崩溃
 @Test
    fun coroutineExceptionTest10(): Unit = runBlocking {
        GlobalScope.async() {
            println("父async协程")
            val deferred = async {
                delay(200)
                println("子async协程")
                throw Exception("子async协程 异常")
            }
            //调用await()
            deferred.await()
        }
        delay(2000)
    }


//运行结果：是不是很出乎意料~居然没有抛出异常导致应用崩溃！
//但是我们刚刚进行异常捕获的时候，明明在deferred.await()处是可以捕获到异常的
//猜测原因:
//deferred.await()处位于父协程内部，故而抛出异常的位置是在于父协程内部的，
//而GlobalScope有默认的全局异常处理器CoroutineExceptionHandler，进行异常处理了，
//故而没有抛异常！

父async协程
子async协程

若有错误，望请指正！

le161616
关注
Kotlin协程之结构化异常详解
喻志强的博客
10-22 914
kotlin协程异常详解
Kotlin协程使用详解
学无止境
07-06 979
协程的挂起可以理解为协程中的代码离开协程所在线程的过程，协程的恢复可以理解为协程中的代码重新进入协程所在线程的过程。而恢复这个功能是协程的，如果你不在协程里面调用，恢复这个功能没法实现，所以也就回答了这个问题：为什么挂起函数必须在协程或者另一个挂起函数里被调用。因为一个挂起函数要么在协程里被调用，要么在另一个挂起函数里被调用，所以不管是直接还是间接地，总是会在一个协程里被调用的。协程范围，指的是协程内的代码运行的时间周期范围，如果超出了指定的协程范围，协程会被取消执行。都不对，我们挂起的对象是协程。
Kotlin 协程的异常处理
xiangxiongfly
04-07 5251
协程的取消需要内部配合。 不要打破协程的父子结构。 捕获 CancellationException 异常后，需要考虑是否重新抛出来。 不要用 try-catch 直接包裹 launch、async。 使用 SurpervisorJob 控制异常传播的范围。 使用 CoroutineExceptionHandler 处理复杂结构的协程异常，仅在顶层协程中起作用。 核心理念：协程是结构化的，异常传播也是结构化的。
Kotlin中协程的异常处理
Android、HTML、CSS、JS、JAVA、Kotlin、PHP等技术
02-14 704
文章目录异常处理的必要性异常的传播非根协程异常异常的传播特性SupervisorJobsupervisorScope异常的捕获Android中全局异常处理取消与异常异常聚合 异常处理的必要性 当应用出现一些意外情况时，给用户提供合适的体验非常重要，一方面，目睹应用崩溃是一个很糟糕的体验， 另一方面，在用户操作失败时，也必须要能给出正确的提示信息。 异常的传播 协程构建器有两种形式：自动传播异常(launch与actor),向用户暴露异常（async与produce）当这些构建器用于创建一个根协程时（
launch 在Kotlin 中怎么使用
最新发布
qq_33386162的博客
05-22 698
在 Kotlin 中，launch是一个非常重要的函数，它通常用于并发编程，特别是与协程（Coroutines）一起使用。协程是 Kotlin 用于实现异步编程的一种机制，而launch是启动一个新协程的函数。
Kotlin教程 协程-异常处理
听海的博客
08-31 781
Kotlin教程 协程-异常处理
【Kotlin 协程】协程异常处理 ① ( 根协程异常处理 | 自动传播异常 | 在协程体捕获异常 | 向用户暴露异常 | 在 await 处捕获异常 | 非根协程异常处理 | 异常传播特性 )
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
12-04 1487
一、协程异常处理、 二、根协程自动传播异常、 1、异常抛出点 ( 协程体抛出异常 )、 2、异常捕获点 ( 在协程体捕获异常 )、 三、根协程向用户暴露异常、 1、异常抛出点 ( 在 await、receive 处抛出异常 )、 2、异常捕获点 ( 在 await、receive 处捕获异常 )、 四、非根协程异常处理、 五、异常传播特性、
协程的异常处理3：协程的异常
chenrenxiang的专栏
11-22 915
我将翻译四篇介绍协程的 取消 和 异常处理 相关的文章，四篇文章是层层递进的关系。翻译过程中我将尽量忠实于原文。当然，由于水平有限，不能保证完全的翻译正确。如果您发现翻译有错误之处，欢迎在评论里指出。我也将贴出每篇翻译的原文。 第一篇：《协程：第一件事》（原文： Coroutines: first things first） 第二篇：《协程的取消》（原文：Cancellation in coroutines） 第三篇：《协程的异常》（原文：Exceptions in coroutines） 第四篇：《不应
Kotlin协程详解（学习协程这一篇就够了）
xielongfeiabcd的博客
03-04 7957
一、什么是协程协程是一种优雅处理异步任务的解决方案 ，可以理解为是Kotlin对「线程」和「Handler」 API 的一种封装形式。它可以在不同的线程间来回切换，这样就可以让代码通过编写的顺序来执行，并且不会阻塞当前线程，省去了在各种耗时操作写回调的情形。在 JVM 平台上，Kotlin 协程是无栈协程，所谓无栈协程，是指协程在 suspend 状态时不需要保存调用栈。
kotlin协程之异常隔离：SupervisorJob & supervisorScope
喻志强的博客
02-09 1189
kotlin协程的异常隔离详解
【Android Kotlin】Kotlin协程介绍
Ho博客
08-29 1641
Kotlin协程的核心内容涵盖了协程的基本概念、构建块、启动方式、挂起函数、结构化并发、异常处理以及协程的取消机制。协程通过提供一种轻量级的并发编程模型，使得处理异步任务更加直观和简洁，同时保持代码的可读性和可维护性。它们在Android开发中得到了广泛应用，尤其是在需要处理复杂的异步操作时。
协程的异常处理 协程上下文 协程的异常捕获
qq_33552379的博客
12-28 1494
一:协程上下文CoroutineContext 协程CoroutineContext上下文组成公式 = 默认值 + 继承的CoroutineContext +参数 默认值 = Dispatchers.Default+CoroutineName("coroutine") 继承的CoroutineContext = CoroutineScope或者其父协程的上下文CoroutineContext 参数 = ...
关于协程异常处理，你想知道的都在这里
chuyouyinghe的专栏
09-14 653
而这就是协程的结构化并发特性。我们在 launch 时，因为启动了一个新的协程作用域，而新的作用域内部已经是新的线程(可以理解为)，因为内部发生异常时因为没有被直接捕获 , 再加上其Job不是 SupervisorJob，所以异常将向上开始传递，因为其本身已经是根协程，此时根协程的 CoroutineContext 也没有携带 CoroutineExceptionHandler，从而导致了直接异常。每个任务都有自己的生命周期，子任务的生命周期会继承父任务的生命周期，比如如果父任务关闭，子任务也会被取消。
kotlin中的异常处理_Kotlin中基于值的类和错误处理
weixin_26741235的博客
09-08 512
kotlin中的异常处理Not to be confused with value types of project Valhalla. 不要与Valhalla项目的价值类型混淆。 Value-based classes, as defined in the Java docs, are classes which conform to a set of rules: Java文档中定义的基于值...
异常处理的使用
enthan809882的博客
04-01 539
异常处理的使用
Kotlin | 关于协程异常处理，你想知道的都在这里
petterp的博客
08-11 1231
关于协程的异常处理，一直以来都不是一个简单问题。因为涉及到了很多方面，包括 异常的传递 ，结构化并发下的异常处理 ,异常的传播方式等，本篇将由浅到深，帮你搞清这些问题。
[译] Kotlin 协程异常处理
hegan2010的博客
06-24 1357
原文：https://github.com/Kotlin/kotlinx.coroutines/blob/master/docs/topics/exception-handling.md 文章目录异常传播协程异常处理器 CoroutineExceptionHandler 本节介绍异常处理和在异常时取消。我们已经知道取消的协程会在挂起点抛出 CancellationException 并且它会被协程的机制忽略。这里我们看看如果在取消过程中抛出异常或者同一个协程的多个子协程抛出异常会发生什么。 异常传播 协程构
发现不一样的Kotlin多方位处理协程的异常
热门推荐
m0_58350991的博客
06-15 1万+
Kotlin 中的协程已经成为在网络请求中比较常用的一种方式，除了正常请求外，我们同样需要处理请求中的异常情况，本篇文章将处理协程中的异常分为以下几个部分： 一、try-catch 1.1 try-catch基础使用 1.2 什么情况下try-catch会无效？ 1.3 什么是协程的结构化并发？ 二、CoroutineExceptionHandler 2.1 CoroutineExceptionHandler的介绍 2.2 CoroutineExceptionHandler的使用 2.3 Coroutin.
Kotlin协程请求处理示例详解
在当今的软件开发领域中，协程（Coroutines）是处理并发任务和异步编程的强大工具，尤其在Kotlin语言中，由于其语言层面提供的协程支持，使得编写高效的异步代码更加简洁。本篇内容将基于标题“请求协程示例”深入...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值