如何并行运行多个 Kotlin 协程并等待它们完成后再继续

Question

我需要并行运行 2 个协程并等待它们完成后再继续。下面的代码有效，但它使用GlobalScope，这不是最好的方法。

有没有更好的办法？

fun getInfo(onSuccess: () -> Unit, onError: () -> Unit) {
        GlobalScope.launch(Dispatchers.IO) {
            try {
                coroutineScope {
                    launch { getOne() }
                    launch { getTwo() }
                }
                onSuccess.invoke()
            } catch (e: Throwable) {
                onError.invoke()
            }
        }
    }

Answer 1

我建议将getInfo 实现为一个挂起函数，该函数知道它应该运行的上下文。这样，您从哪个上下文调用它都无关紧要 (*)。

此外，之后我不会使用回调来继续。 您可以根据getInfo() 返回的内容来决定如何继续（**）。

这实际上是协程最棒的地方，您可以将基于回调的代码转换为读起来像顺序代码的代码。

由于您不关心getOne() 和getTwo() 的结果，因此使用launch 是正确的方法。它返回一个Job。您可以暂停协程，直到两个函数都使用 joinAll() 完成，这可以在 Collection<Job> 上调用。

suspend fun getInfo() = withContext(Dispatchers.IO) {
    try {
        listOf(
            launch { getOne() },
            launch { getTwo() }
        ).joinAll()
        false
    } catch (e: Throwable) {
        true
    }
}

您不需要使用GlobalScope，只需创建您自己的 (***)。

我使用Default 作为启动getInfo 的上下文，但任何其他上下文也可以，因为getInfo 将在它应该运行的那个上运行。

val newScope = CoroutineScope(Dispatchers.Default).launch {
    val error = getInfo()
    if(error) {
        onSuccess()
    } else {
        onError()
    }
}
// "newScope" can be cancelled any time

---

_{* 如果我用Dispatcher.IO 假装这两个函数正在做一些长时间运行的 IO 工作。}

_{** 我在这里使用了一个简单的布尔值，但当然你可以返回更有意义的值。}

*** 或挂钩到由具有生命周期感知能力的复杂框架给出的某个范围

Answer 2

您可以使用任何您喜欢的范围。这不影响你的问题。不鼓励使用 GlobalScope，因为它不封装您的任务。

实际使用哪个范围来启动您的协程将完全取决于您正在执行的操作的上下文以及您使用的封装策略。

要一次启动多个协程并等待所有协程，您可以使用async 和await()。如果您只需要在继续之前完成所有这些操作，您可以在列表中使用awaitAll()。

您使用 IO 调度程序来运行您的回调似乎很奇怪，但我会保留它，因为我对您的代码上下文视而不见。

fun getInfo(onSuccess: () -> Unit, onError: () -> Unit) {
        GlobalScope.launch(Dispatchers.IO) {
            try {
                coroutineScope {
                    listOf(
                        async { getOne() }
                        async { getTwo() }
                    }.awaitAll()
                }
                onSuccess.invoke()
            } catch (e: Throwable) {
                onError.invoke()
            }
        }
    }

Answer 3

您可以在您正在处理的类中创建一个CoroutineScope，只需调用launch builder 即可构建协程。像这样的：

class MyClass: CoroutineScope by CoroutineScope(Dispatchers.IO) { // or [by MainScope()]

    fun getInfo(onSuccess: () -> Unit, onError: () -> Unit) {
        launch {
            try {
                val jobA = launch { getOne() }
                val jobB = launch { getTwo() }
                joinAll(jobA, jobB)
                onSuccess.invoke()
            } catch (e: Throwable) {
                onError.invoke()
            }
        }
    }

    fun clear() { // Call this method properly
        this.cancel()
    }

}

确保通过正确调用cancel 来取消在作用域内运行的任何协程。

或者，如果您在 ViewModel 中工作，只需使用 viewModelScope。

Answer 4

实际上，根据公认的答案，还有更好的方法：

suspend fun getInfo() = withContext(Dispatchers.IO) {
try {
    coroutineScope {
        launch { getOne() }
        launch { getTwo() }
    }
    false
} catch (e: Throwable) {
    true
}

}