java程序员的kotlin课（N+2）：suspending函数执行编排

英文原文

执行编排指的是对异步函数的执行顺序进行控制，举个简单的例子：
需要调用a、b两个函数，从高效的角度讲a、b并行调用有一定是最佳的，但是如果b函数的输入依赖a函数的输出，那就只能做串行调用。
针对a、b两个函数执行顺序的控制，即本节要讲的执行编排，原文中的 Composing Suspending Functions

默认串行执行

假设我们有两个suspending的函数，可能是远程调用（rpc）。我们假装这两个函数很有用，虽然这两个函数只是简单的delay了一下.

suspend fun doSomethingUsefulOne(): Int {
    delay(1000L) // pretend we are doing something useful here
    return 13
}

suspend fun doSomethingUsefulTwo(): Int {
    delay(1000L) // pretend we are doing something useful here, too
    return 29
}

我们如何让这两个函数串行的执行呢？依次执行doSomethingUsefulOne和doSomethingUsefulTwo，然后计算两个函数结果的和，请看下面的代码（为了计算两个函数总的执行时间，此处利用了measureTimeMillis函数）

val time = measureTimeMillis {
    val one = doSomethingUsefulOne()
    val two = doSomethingUsefulTwo()
    println("The answer is ${one + two}")
}
println("Completed in $time ms")

执行结果如下：

The answer is 42
Completed in 2017 ms

并行执行异步操作

如果两次函数调用之间没有有起来关系，我们就可以并行的执行两个函数了，这样执行起来总的耗时会减少。
从概念上讲，async和launch是相似的。他们都可以启动一个协程，区别在于launch返回一个job对象，job对象不携带任何结果相关的信息。而async返回一个Deferred类型的对象，和future类似，不过这个是在协程背景下的，可以通过.await()函数来获得结果。而且Deferred也是一个job，一样可以用来cancel协程。

val time = measureTimeMillis {
    val one = async { doSomethingUsefulOne() }
    val two = async { doSomethingUsefulTwo() }
    println("The answer is ${one.await() + two.await()}")
}
println("Completed in $time ms")

输出结果如下：

The answer is 42
Completed in 1017 ms

执行速度有两倍的提升，因为两个协程是并行执行的。谨记：利用协程的并行永远是显式的。

延迟启动异步动作

作为一个可选项，在使用async关键字启动协程的时候，可以传入参数CoroutineStart.LAZY。在这种模式下，协程启动的时机：

await函数被调用时
start函数被调用时

val time = measureTimeMillis {
    val one = async(start = CoroutineStart.LAZY) { doSomethingUsefulOne() }
    val two = async(start = CoroutineStart.LAZY) { doSomethingUsefulTwo() }
    // some computation
    one.start() // start the first one
    two.start() // start the second one
    println("The answer is ${one.await() + two.await()}")
}
println("Completed in $time ms")

结果如下：

The answer is 42
Completed in 1017 ms

上面的例子中，两个协程并没有像之前的例子一样立刻启动，启动的控制权交给了编码者，编码者可以通过start函数或者await函数进行启动。
但是需要注意的是，如果使用await来触发协程的启动，上面的例子会变为串行执行，因为aswit函数会等待协程执行完毕才向下执行接下来的动作。

异步风格的函数

我们可以通过 async coroutine builder 和显式的 GlobalScope来把 doSomethingUsefulOne函数和doSomethingUsefulTwo函数声名为异步函数：

// The result type of somethingUsefulOneAsync is Deferred<Int>
fun somethingUsefulOneAsync() = GlobalScope.async {
    doSomethingUsefulOne()
}

// The result type of somethingUsefulTwoAsync is Deferred<Int>
fun somethingUsefulTwoAsync() = GlobalScope.async {
    doSomethingUsefulTwo()
}

请注意，上面的xxxAsync函数并不是suspending函数，他们可以在任何地方被调用。下面的代码是用来调用上面两个函数的代码:

// note that we don't have `runBlocking` to the right of `main` in this example
fun main() {
    val time = measureTimeMillis {
        // we can initiate async actions outside of a coroutine
        val one = somethingUsefulOneAsync()
        val two = somethingUsefulTwoAsync()
        // but waiting for a result must involve either suspending or blocking.
        // here we use `runBlocking { ... }` to block the main thread while waiting for the result
        runBlocking {
            println("The answer is ${one.await() + two.await()}")
        }
    }
    println("Completed in $time ms")
}

上面这种编码风格仅用来展示，因为在其他语言中，这是一种很流行的编码方式，但是在kotlin中这种编码风格是强烈不推荐的。
还记得前几章有讲过一个词结构化并发或者英文原版structured concurrency，啥意思呢，就是当父协程取消、异常、关闭时，需要保证子协程都有被正确的取消，避免资源泄漏。
那么上面的代码呢？如果val one = somethingUsefulOneAsync()这一行到one.await()这一行发生任何错误，会怎样？主协程停止了，报错了，但是子协程会一直执行。

通过async做结构化异步编程

所以上面的例子，还是需要进行结构化的编码风格来做：

fun main() = runBlocking {
  var a = async { doSomethingUsefulOne() }
  var b = async { doSomethingUsefulTwo() }
  println(a.await() + b.await())
}

suspend fun doSomethingUsefulOne(): Int {
  delay(1024)
  return 23
}

suspend fun doSomethingUsefulTwo(): Int {
  delay(800)
  return 35
}

这种编码风格，如果main中发生任何错误，所有的子协程都将被取消。

fun main() = runBlocking {
  var a = async { doSomethingUsefulOne() }
  var b = async { doSomethingUsefulTwo() }
  println(a.await() + b.await())
}

suspend fun doSomethingUsefulOne(): Int {
  delay(200)
  throw RuntimeException()
  return 23
}

suspend fun doSomethingUsefulTwo(): Int {
  try {
    //永远都不会被执行
    delay(Long.MAX_VALUE)
    return 35
  } finally {
    println("cancel.")
  }
}

读者可以自己试一下上面的代码。

系列文章快速导航：
java程序员的kotlin课（一）：环境搭建
 java程序员的kotlin课（N）：coroutines基础
 java程序员的kotlin课（N+1）：coroutines 取消和超时
 java程序员的kotlin课（N+2）：suspending函数执行编排