Kotlin协程中async/await并行执行的奥秘：理解操作符优先级的影响

本文深入探讨了kotlin协程中`async`和`await`的并发机制，特别强调了操作符优先级对并行执行的影响。通过对比两种不同的`async/await`使用方式，揭示了为何不当的`await`调用顺序会导致任务串行化，而非预期的并行执行，从而指导开发者如何正确实现高效的并发操作，避免因误解而造成的性能瓶颈。

Kotlin协程中的并发基础：async与await

Kotlin协程提供了一种轻量级的并发编程方式，通过suspend函数和结构化并发机制，使得编写异步代码变得更加简洁和易于管理。在协程中，async函数用于启动一个新的协程并在后台执行任务，它会立即返回一个Deferred对象，代表了未来某个时刻会产生的结果。而await函数则用于阻塞当前协程，直到其所关联的Deferred任务完成并返回结果。

考虑以下两个模拟耗时操作的suspend函数：

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

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

我们的目标是并行执行这两个函数，以期在最短的时间内获取它们的总和。

正确实现并行执行

要实现真正的并行执行，关键在于确保所有需要并发启动的任务都在等待结果之前被调度。当使用async时，它会立即启动一个新的协程并返回一个Deferred对象。如果我们在所有async任务都启动之后才调用await，那么这些任务就能在后台并发执行。

以下是实现并行执行的正确方式：

import kotlinx.coroutines.*

fun main() = runBlocking {
    val a = async { doSomethingUsefulOne() } // 任务1立即启动
    val b = async { doSomethingUsefulTwo() } // 任务2立即启动

    // 在所有任务都已启动后，才等待它们的结果
    println("结果: ${a.await() + b.await()}")
}

执行分析：

1. async { doSomethingUsefulOne() } 会立即启动一个协程来执行 doSomethingUsefulOne()，并返回一个 Deferred<Int> 对象赋值给 a。
2. 紧接着，async { doSomethingUsefulTwo() } 也会立即启动另一个协程来执行 doSomethingUsefulTwo()，并返回一个 Deferred<Int> 对象赋值给 b。
3. 此时，两个耗时3秒的任务已经同时在后台运行。
4. a.await() 会等待第一个任务完成（约3秒）。
5. b.await() 会等待第二个任务完成。由于第二个任务与第一个任务是并行执行的，当 a.await() 完成时，b.await() 可能已经完成或接近完成。
6. 因此，整个操作的总耗时约为 3秒。

这种方式确保了async所创建的协程能够立即开始执行，从而实现了真正的并行。

MarsX

AI驱动快速构建App，低代码无代码开发，改变软件开发的游戏规则

159

查看详情

错误的并行尝试：操作符优先级陷阱

然而，如果对async和await的使用方式稍作调整，即使看起来像是并行，也可能导致任务串行执行，从而大大增加总耗时。考虑以下代码：

import kotlinx.coroutines.*

fun main() = runBlocking {
    println("结果: ${async { doSomethingUsefulOne() }.await() + async { doSomethingUsefulTwo() }.await()}")
}

执行分析： 这段代码的执行结果会是约 6秒，而非期望的3秒。其根本原因在于Kotlin（以及大多数编程语言）中操作符的优先级和求值顺序。

1. 加法操作符 (+) 的求值顺序：+ 操作符要求其左侧的表达式必须完全求值完毕，才能开始求值其右侧的表达式。

2. 左侧表达式求值： 首先，程序会尝试求值 async { doSomethingUsefulOne() }.await()。

   • async { doSomethingUsefulOne() } 会启动第一个协程并返回一个 Deferred 对象。
   • 紧接着，.await() 会立即被调用。这意味着当前协程会暂停执行，直到 doSomethingUsefulOne() 完成并返回结果（耗时3秒）。
   • 只有当 doSomethingUsefulOne() 完成后，左侧的整个表达式 async { doSomethingUsefulOne() }.await() 才算求值完毕。

3. 右侧表达式求值： 在左侧表达式完全求值完毕（即第一个任务已完成并返回结果）之后，程序才会开始求值右侧的表达式 async { doSomethingUsefulTwo() }.await()。

   • async { doSomethingUsefulTwo() } 会启动第二个协程并返回一个 Deferred 对象。
   • .await() 同样会立即被调用，使当前协程再次暂停，直到 doSomethingUsefulTwo() 完成并返回结果（又耗时3秒）。

总结： 由于加法操作符的求值顺序，第二个 async 任务的启动被延迟了，直到第一个 async 任务及其 await 完成。这导致两个任务实际上是串行执行的，总耗时叠加为 3秒 + 3秒 = 6秒。

类似场景的类比

这种行为类似于短路求值（short-circuit evaluation）的逻辑操作符，例如Kotlin中的 ||（或）和 &&（与）。 考虑以下布尔表达式：

someBooleanResponse(a, b, c) || someOtherBooleanExpression(d, e)

在这个表达式中，someBooleanResponse(a, b, c) 会被完全评估。只有当它的结果为 false 时，才会去评估右侧的 someOtherBooleanExpression(d, e)。如果左侧为 true，右侧甚至根本不会执行。这同样体现了从左到右的求值顺序。

最佳实践与注意事项

为了确保async任务能够真正并行执行，请遵循以下最佳实践：

1. 先启动所有async任务，再await： 将所有async调用赋值给独立的Deferred变量，确保它们在同一作用域内被调度启动，然后再通过这些变量调用await来获取结果。

   val deferredResult1 = async { task1() }
   val deferredResult2 = async { task2() }
   // ...
   val result1 = deferredResult1.await()
   val result2 = deferredResult2.await()
   // 现在可以安全地使用 result1 和 result2

   登录后复制

2. 理解操作符优先级： 在编写包含async/await的复杂表达式时，务必考虑操作符的优先级和求值顺序。当一个表达式的子部分需要等待结果时，它会阻碍整个表达式的进一步求值。

3. 使用awaitAll处理多个Deferred： 如果需要等待多个Deferred对象完成，可以使用awaitAll()函数，它会并行等待所有Deferred对象的结果，并以列表形式返回。

   val results = listOf(
       async { doSomethingUsefulOne() },
       async { doSomethingUsefulTwo() }
   ).awaitAll()
   println("结果: ${results.sum()}")

   登录后复制

总结

Kotlin协程的async和await为实现并发提供了强大的工具，但要实现真正的并行效率，开发者必须理解其背后的执行机制，尤其是操作符优先级对求值顺序的影响。通过先启动所有async任务再统一await，可以有效避免因误解而导致的串行化问题，从而充分发挥协程的并行处理能力。始终记住，async负责启动任务，而await负责等待结果，合理安排它们的调用顺序是编写高效并发代码的关键。

以上就是Kotlin协程中async/await并行执行的奥秘：理解操作符优先级的影响的详细内容，更多请关注php中文网其它相关文章！