Kotlin协程中async与await的并发陷阱与正确实践

本文深入探讨kotlin协程中`async`与`await`在实现并发时的常见误区。通过对比两种不同的代码结构，揭示了运算符优先级如何导致看似并行的代码实则串行执行。文章详细解释了为何应先启动所有异步任务，再统一等待结果，从而有效利用协程实现真正的并发，避免不必要的延迟，优化程序性能。

在Kotlin协程中，async和await是实现并发操作的关键工具。async函数用于启动一个新的协程，并在后台执行一个计算，它会立即返回一个Deferred对象，代表了未来某个时刻会得到的结果。而await函数则是一个挂起函数，它会暂停当前协程的执行，直到其关联的Deferred对象中的结果可用。理解它们的工作机制，尤其是在表达式中的求值顺序，对于编写高效的并发代码至关重要。

理解async和await的基础用法

假设我们有两个挂起函数，它们分别模拟耗时操作：

suspend fun doSomethingUsefulOne(): Int {
    delay(3000L) // 模拟3秒的耗时操作
    return 20
}

suspend fun doSomethingUsefulTwo(): Int {
    delay(3000L) // 模拟3秒的耗时操作
    return 10
}

为了并行执行这两个函数并获取它们的总和，一种常见的做法是使用async。

并发执行的正确姿势

要实现真正的并行，我们需要确保两个async任务几乎同时启动，然后等待它们的结果。以下是正确的实现方式：

import kotlinx.coroutines.*

fun main() = runBlocking {
    val startTime = System.currentTimeMillis()

    // 1. 启动第一个异步任务，获取Deferred对象
    val a: Deferred<Int> = async { doSomethingUsefulOne() }
    // 2. 启动第二个异步任务，获取Deferred对象
    val b: Deferred<Int> = async { doSomethingUsefulTwo() }

    // 3. 同时等待两个任务的结果
    val result = a.await() + b.await()
    println("并行执行结果: $result")
    println("并行执行耗时: ${System.currentTimeMillis() - startTime} ms")
}

运行结果分析：

STORYD

帮你写出让领导满意的精美文稿

164

查看详情

这段代码的执行时间大约是 3秒。这是因为async { doSomethingUsefulOne() }和async { doSomethingUsefulTwo() }这两个语句会几乎立即启动两个独立的协程。它们在后台并行运行。当代码执行到a.await()时，它会等待第一个任务完成；当执行到b.await()时，它会等待第二个任务完成。由于两个任务是并行进行的，总耗时由其中最长的任务决定（本例中两者都是3秒）。

并发陷阱：运算符优先级导致的串行执行

现在，我们来看一个容易导致误解的代码片段，它看似并行，实则串行：

import kotlinx.coroutines.*

fun main() = runBlocking {
    val startTime = System.currentTimeMillis()

    val result = async { doSomethingUsefulOne() }.await() + async { doSomethingUsefulTwo() }.await()
    println("串行执行结果: $result")
    println("串行执行耗时: ${System.currentTimeMillis() - startTime} ms")
}

运行结果分析：

这段代码的执行时间大约是 6秒。为什么会这样呢？原因在于Kotlin（以及大多数编程语言）中运算符的求值顺序。加法运算符+要求其左侧的操作数必须完全求值完毕，才能开始求值其右侧的操作数。

具体来说，表达式async { doSomethingUsefulOne() }.await() + async { doSomethingUsefulTwo() }.await()的求值过程如下：

1. 首先求值左侧操作数： async { doSomethingUsefulOne() }.await()
   • async { doSomethingUsefulOne() }会启动第一个协程，并返回一个Deferred对象。
   • .await()会立即暂停当前协程，直到doSomethingUsefulOne()完成并返回结果。这个过程耗时 3秒。
   • 在左侧操作数完全求值完成（即doSomethingUsefulOne()返回20）之前，加法运算符的右侧部分根本不会开始执行。
2. 然后求值右侧操作数： async { doSomethingUsefulTwo() }.await()
   • 只有当左侧操作数求值完毕后，async { doSomethingUsefulTwo() }才会被调用，启动第二个协程。
   • .await()会暂停当前协程，直到doSomethingUsefulTwo()完成并返回结果。这个过程又耗时 3秒。
3. 最后执行加法运算： 将两个结果相加。

因此，由于加法运算符的求值顺序，两个耗时3秒的任务被强制串行执行，导致总耗时叠加为6秒。

核心原理：表达式求值与短路行为

这种行为并非Kotlin协程特有，而是许多语言中表达式求值的基本规则。例如，在布尔逻辑运算中，我们经常利用短路求值：

fun someBooleanResponse(a: Any, b: Any, c: Any): Boolean { /* ... */ return true }
fun someOtherBooleanExpression(d: Any, e: Any): Boolean { /* ... */ return false }

// 表达式 someBooleanResponse(...) || someOtherBooleanExpression(...)
// 如果someBooleanResponse(...)返回true，则someOtherBooleanExpression(...)根本不会被求值。

同样的道理，对于A + B这样的表达式，A必须完全确定其值后，B才会被求值。如果A的求值过程中涉及耗时操作（如await()），那么B的求值就会被延迟。

最佳实践与注意事项

1. 先启动，后等待： 实现并发的关键在于，先通过async或launch启动所有独立的并发任务，获取它们的Deferred或Job对象，然后再统一使用await()或join()等待它们的结果。
2. 理解运算符优先级： 始终注意表达式中运算符的求值顺序，避免因隐式的串行化而导致性能问题。
3. async的返回值： async函数会立即返回一个Deferred对象，这意味着它只是启动了任务，任务本身可能还在后台运行。await()才是等待结果并挂起的地方。
4. 结构化并发： 在coroutineScope或runBlocking这样的协程作用域内使用async，可以确保所有启动的子协程都会在外部作用域结束前完成或被取消，从而实现结构化并发。

总结

通过本文的分析，我们了解到在Kotlin协程中使用async和await实现并发时，必须注意表达式的求值顺序。将async { ... }.await()直接嵌入到需要求值左右操作数的表达式（如加法运算）中，会导致任务串行执行，从而失去并发的优势。正确的做法是先将所有async任务的结果（Deferred对象）保存起来，确保它们几乎同时启动，然后再统一调用await()来获取结果。遵循这一原则，可以有效利用Kotlin协程的强大功能，编写出真正高效和响应迅速的并发应用程序。

以上就是Kotlin协程中async与await的并发陷阱与正确实践的详细内容，更多请关注php中文网其它相关文章！