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

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

AI Word

一款强大的 AI 智能内容创作平台，致力于帮助用户高效生成高质量、原创且符合 SEO 规范的各类文章。

226

查看详情

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

然而，如果对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中文网其它相关文章！