Kotlin协程（二）

取消与超时

1 取消协程的执行

在长时间运行的应用程序中，需要对后台协程进行细粒度的控制。比如当一个用户关闭了启动协程的界面，那么这时候协程的运行结果就不重要了，我们需要关闭正在运行的协程。

	fun main() = runBlocking {
//        printWorld()
        val job = launch {
            repeat(1000) { i ->
                delay(500)
                Log.d(TAG, "it is $i")
            }
        }
        delay(1300)
        Log.d(TAG, "do not wait so long")
        job.cancel() //取消该作业
        job.join() //等待作业执行结束
        Log.d(TAG, "stopped!!!")
    }

运行结果

一旦 main 函数调用了 job.cancel，我们在其它的协程中就看不到任何输出，因为它被取消了。也可以使用 job.cancelAndJoin() 方法，结合cancel()和join()方法

2 协程的取消

线程的中断：线程的中断不是立即进行的，当调用 interrupt 方法后，会在当前运行的线程上设置打断标记，当下一次运行到判断打断标记的时候再进行终止。不论如何，线程的创建与销毁都是消耗系统资源的，并不是一个高效的方案。倒不如维护一个线程池，有任务来了就消费，省去了频繁创建销毁线程带来的开销。当线程正在 sleep、wait时会抛出InterruptedException异常，通过捕获异常并作资源处理

Kotlin的协程提供了较为优雅的取消方式，这也是协程的核心优势之一。它的中断方式与线程类似，协程的取消是协作的。

	fun main() = runBlocking {
    val job1 = launch { // ①
        log(1)
        delay(1000) // ②
        log(2)
    }
    delay(100)
    log(3)
    job1.cancel() // ③
    log(4)
}

输出： 1 3 4

这段代码 ① 处启动了一个子协程，它内部先输出 1，接着开始 delay， delay 与线程的 sleep 不同，它不会阻塞线程，你可以认为它实际上就是触发了一个延时任务，告诉协程调度系统 1000ms 之后再来执行后面的这段代码（也就是 log(2)）；而在这期间，我们在 ③ 处对刚才启动的协程触发了取消，因此在 ② 处的 delay 还没有回调的时候协程就被取消了，因为 delay 可以响应取消，因此 delay 后面的代码就不会再次调度了，不调度的原因也很简单，② 处的 delay 会抛一个 CancellationException：

	fun main() = runBlocking {
        val job = launch {
            Log.d(TAG, "1")
            try {
                delay(1000)
            } catch (e: Exception) {
                Log.d(TAG, "$e")
            }
            Log.d(TAG, "2")
        }
        delay(100)
        Log.d(TAG, "3")
        job.cancel() //取消该作业
        Log.d(TAG, "4")
    }

输出结果：

可见在协程取消后，依旧执行打印了2

3 超时

在实践中大多数协程都可能会超时，可以使用withTimeout 函数处理超时

	fun main() = runBlocking {
        try {
            withTimeout(1500) {
                repeat(1000) {
                    Log.d(TAG, "main: this is $it")
                    delay(400)
                }
            }
        } catch (e: Exception) {
            Log.d(TAG, "main: $e")
        }
    }

运行结果：

也可以使用 withTimeoutOrNull 替代 withTimeout ，而 withTimeoutOrNull 通过返回 null 来进行超时操作，从而替代抛出一个异常：

	fun main() = runBlocking {
        try {
            val result =  withTimeoutOrNull(1000) {
                Log.d(TAG, "main: starting...")
                delay(1500)
                "ending"
            }
            Log.d(TAG, "main: $result")
        } catch (e: Exception) {
            Log.d(TAG, "main: $e")
        }
    }

运行结果