java程序员的kotlin课（N+1）：coroutines

本文大部分翻译至：https://kotlinlang.org/docs/reference/coroutines/cancellation-and-timeouts.html
做了轻微优化
为什么翻译
我知道有一般中文版的文档，之所以还进行翻译有两个原因：

• 看了好几遍，总是记不住，翻译一下，加深一下印象
• 翻译的版本和原版的英文版，笔者认为讲的不够简单

为什么是N+1
kotlin系列文章照理说应该有一系列的文章，协程绝对应该是排在靠后的位置的，但是因为笔者最近一直在看这块的东西，而一些基础类的kotlin的文章反而没有写，所以协程系列文章以N开始，这是第二篇，所以是N+1

取消协程执行

在长时间执行的应用中，你也许需要对后台运行的协程有合适粒度的控制。举例来讲，比如用户已经关闭了某一个页面，那么后台运行的用来加载页面数据的协程就没有必要继续运行了并且应该被取消。lanch函数会返回一个job对象，这个job对象可以用来取消运行中的协程：

val job = launch {
    repeat(1000) { i ->
        println("job: I'm sleeping $i ...")
        delay(500L)
    }
}
delay(1300L) // delay a bit
println("main: I'm tired of waiting!")
job.cancel() // cancels the job
job.join() // waits for job's completion 
println("main: Now I can quit.")

这会产生如下的输出内容：

job: I'm sleeping 0 ...
job: I'm sleeping 1 ...
job: I'm sleeping 2 ...
main: I'm tired of waiting!
main: Now I can quit.

一但主函数执行了job.cancel，我们再也看不到协程有输出，因为它被取消了。job对象还有另外一个拓展函数cancelAndJoin,这个函数会融合cancel和join两个操作。

取消是需要配合的

协程的取消是需要内外一起配合的（此处有点拗口，后面不按照原文进行翻译了），啥意思呢？就是协程的取消，需要协程执行体内部配合外部的取消信号的；如果熟悉java的线程取消，大家可能会知道，如果是阻塞的方法，被取消会抛出·InterruptedException·，而非阻塞方法如果需要取消，必须在关键节点进行检查，检查线程当前是否被中断。协程也是一样的，如果一个协程内部没有suspend的代码，又没有在关键点设立检查点，协程是无法被取消的。比如下面这段代码，一个while循环没有设置任何协程取消检查点，所以在mian函数里调用了cancelAndJoin之后，协程内部依然不会停止执行。

val startTime = System.currentTimeMillis()
val job = launch(Dispatchers.Default) {
    var nextPrintTime = startTime
    var i = 0
    while (i < 5) { // computation loop, just wastes CPU
        // print a message twice a second
        if (System.currentTimeMillis() >= nextPrintTime) {
            println("job: I'm sleeping ${i++} ...")
            nextPrintTime += 500L
        }
    }
}
delay(1300L) // delay a bit
println("main: I'm tired of waiting!")
job.cancelAndJoin() // cancels the job and waits for its completion
println("main: Now I can quit.")

关于线程的取消，可以参考一下笔者早些年写的一篇java 线程池与通过Future终止线程实例

让协程可以被取消

让协程可以被取消，有两种思路：

• 因为suspending的函数是可以被取消的，所以定期的调用一下suspending的方法，用来检查当前协程是否被取消。有一个函数yield是用来做这个的一个好选择
• 另一个是显式的检查被取消的状态
  现在让我们来看下后一种方案：

val startTime = System.currentTimeMillis()
val job = launch(Dispatchers.Default) {
    var nextPrintTime = startTime
    var i = 0
    while (isActive) { // cancellable computation loop
        // print a message twice a second
        if (System.currentTimeMillis() >= nextPrintTime) {
            println("job: I'm sleeping ${i++} ...")
            nextPrintTime += 500L
        }
    }
}
delay(1300L) // delay a bit
println("main: I'm tired of waiting!")
job.cancelAndJoin() // cancels the job and waits for its completion
println("main: Now I can quit.")

现在如你所见，这个循环是可以被取消了。isActive是一个在CoroutineScope内部可用的拓展属性。

通过finally做取消后的善后工作

关闭suspending的函数，会抛出CancellationException异常，这个异常可以按照常规做法来进行处理，比如try {...} finally {...}

val job = launch {
    try {
        repeat(1000) { i ->
            println("job: I'm sleeping $i ...")
            delay(500L)
        }
    } finally {
        println("job: I'm running finally")
    }
}
delay(1300L) // delay a bit
println("main: I'm tired of waiting!")
job.cancelAndJoin() // cancels the job and waits for its completion
println("main: Now I can quit.")

join和cancelAndJoin函数会等待finally动作执行完毕，所以上面的例子，会输出如下：

job: I'm sleeping 0 ...
job: I'm sleeping 1 ...
job: I'm sleeping 2 ...
main: I'm tired of waiting!
job: I'm running finally
main: Now I can quit.

在finally里执行non-cancellable的代码

上面的代码演示了我们可以在finally的代码块中执行资源回收的操作，但是如果finally的代码块中执行suspend的代码会怎样？

val job = launch(Dispatchers.Default) {
    try {
      while (isActive){
        println("do sth.")
        delay(1000)
      }
    } finally {
      println("do in the finally")
      delay(10000)
      println("finally done.")
    }
  }

  delay(1300L) // delay a bit
  println("main: I'm tired of waiting!")
  job.cancelAndJoin() // cancels the job and waits for its completion
  println("main: Now I can quit.")

输出如下：

do sth.
do sth.
main: I'm tired of waiting!
do in the finally
main: Now I can quit.

finally done并没有被打印。
原因：我们的代码里在main中取消了协程的执行，协程内部的finally里又执行了delay方法，这个方法会使协程进入suspending状态，而协程被取消时suspending的执行函数会被取消。
但是因为finally里执行的都是需要做扫尾工作的动作，如果被取消，可能会造成资源泄漏问题，解决方案是用过withContext(NonCancellable){...}来包装扫尾工作的代码， 读者可以自己试一下。

超时

withTimeout(1300L) {
    repeat(1000) { i ->
        println("I'm sleeping $i ...")
        delay(500L)
    }
}

代码输出如下：

I'm sleeping 0 ...
I'm sleeping 1 ...
I'm sleeping 2 ...
Exception in thread "main" kotlinx.coroutines.TimeoutCancellationException: Timed out waiting for 1300 ms

代码打印了一个异常的堆栈信息，抛出了一个TimeoutCancellationException,它继承至CancellationException。我们之前在取消一个协程的时候，从来没有看到过console中有打印过这个异常信息，因为CancellationException被认为是协程内外用来做配合的常规异常。当然如果一个协程不是可取消的，那么timeout对它也是无可奈何的，比如下面这段代码：

withTimeout(1000) {
    launch {
      while (true){
        println(1)
      }
    }
  }
  println("done")

在看下面这段代码

val result = withTimeoutOrNull(1300L) {
    repeat(1000) { i ->
        println("I'm sleeping $i ...")
        delay(500L)
    }
    "Done" // will get cancelled before it produces this result
}
println("Result is $result")

这段代码因为使用了withTimeoutOrNull, 当超时时并不会抛出异常，而是会返回空。读者可以自己试一下。

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