asynchronous - 使用 kotlin 协程并行分解独立异步任务

Question

我正在尝试并行运行多个任务，但这些任务是独立的，因此如果其中一个子协程失败，我不希望它的 sibling 或父协程也失败。在下面的代码中，我使用 coroutineScope 创建了一个新的范围，这些任务在其中运行并启动了 5 个异步任务，每个任务发送它的 id 和它应该等待的延迟时间。第二个协程抛出异常。在这种情况下，代码执行我希望它执行的操作，它计算成功完成的作业和失败返回 0 的作业的总和。

但是，我读到 kotlinx 库中也有 supervisorScope，它应该是首选而不是 coroutineScope(如果不处理异常，它会取消父/兄弟)，因为任务不依赖于其他任务。我不确定为什么我应该改为使用 supervisorScope，因为我正在使用 coroutineScope 获得我想要的结果。

Q1:如果我要更改为 supervisorScope，我的异步 block 中是否应该发生一些变化？

Q2:是否接受在异步 block 内捕获任何异常并且不让任何内容传播到其父级？我知道您也可以在 .await() 阶段捕获异常，但这是应该完成的方式吗？

runBlocking {
    coroutineScope {
            val job1 = async<Int> {
                try {
                    request(1, 1000)
                } catch (e: Exception) {
                    println("Job 1 failed with $e")
                    0
                }
            }

            val job2 = async<Int> {
                try {
                    request(2, 2000)
                    throw Exception("cancelling Job 2")
                } catch (e: Exception) {
                    println("Job 2 failed: $e")
                    0
                }
            }

            val job3 = async {
                try {
                    request(3, 3000)
                } catch (e: Exception) {
                    println("Job 3 failed with $e")
                    0
                }
            }

            val job4 = async {
                try {
                    request(4, 4000)
                } catch (e: Exception) {
                    println("Job 4 failed with $e")
                    0
                }
            }

            val job5 = async {
                try {
                    request(5, 5000)
                } catch (e: Exception) {
                    println("Job 5 failed with $e")
                    0
                }
            }

            val result = job1.await() + job2.await() + job3.await() + job4.await() + job5.await()
            println(result.toString())
        }

        println("Finished")
}

suspend fun request(id: Int, time: Long): Int {
    println("Job $id started")
    delay(time)
    println("Job $id finished")
    return id
}

Answer 1

所有协程运行到完成的原因是您在作业 2 本身中捕获作业 2 抛出的异常，因此它永远不会向上传播 Job 的层次结构，所以什么也不会发生。

但是，如果您在 job2 中删除那个 catch 子句，则 job[1-5] 将始终被取消，无论您是使用 coroutineScope 还是 supervisorScope 。

这是因为 job2.await() 会抛出异常。由于这发生在作业 [1-5] 的父作业中(即在顶部 coroutineScope/supervisorScope 中)，并且由于失败/取消的父作业总是取消子作业, job[1-5] 也将被取消。

A1:不使用coroutineScope或supervisorScope，移除coroutineScope并将东西直接放在下运行阻塞。

A2:当然允许在 async { } 中捕获异常，以确保它不会在 .await() 中发生如果它适合您的用例。