深入理解 Kotlin coroutine (二)

原文链接：https://github.com/enbandari/Kotlin-Tutorials

上周我们把 Kotlin Coroutine 的基本 API 挨个讲了一下，也给出了一些简单的封装。

真是不要太给脸，就在前几天发布的 1.1 Beta 2 当中，所有协程的 API 包名后面都加了一个 experimental，这意味着 Kotlin 官方在 1.1 当中还是倾向于将 Coroutine 作为一个实验性质的特性的，不过，这也没关系，我们学习的心不以外界的变化而变化不是？

这一篇我们基于前面的基础来了解一下 Kotlinx.coroutines 这个库的使用，如果大家对它的实现原理有兴趣，可以再读一读上一篇文章，我们也可以在后面继续写一些文章来给深入地大家介绍。

1. 准备工作

就像前面我们说到的，1.1 Beta 2 当中协程相关的基础库的包名都增加了 experimental，所以我们在选择 kotlinx.coroutines 的版本的时候也一定要对应好编译器的版本，不然…你自己想哈哈。

我们强调一下，kotlin 的版本选择 1.1.0-beta-38，kotlinx.coroutines 的版本选择 0.6-beta，如果你恰好使用 gradle，那么告诉你一个好消息，我会直接告诉你怎么配置：

buildscript { 
    ext.kotlin_version = '1.1.0-beta-38' 
　 
    repositories { 
        jcenter() 
　 
        maven { 
            url "http://dl.bintray.com/kotlin/kotlin-eap-1.1" 
        } 
    } 
　 
    ... 
} 
　 
repositories { 
    jcenter() 
　 
    maven { 
        url "http://dl.bintray.com/kotlin/kotlin-eap-1.1" 
    } 
} 
　 
kotlin { 
    experimental { 
        coroutines 'enable' 
    } 
} 
　 
dependencies { 
    compile "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version" 
    compile 'org.jetbrains.kotlinx:kotlinx-coroutines-core:0.6-beta' 
} 

2. 一个基本的协程的例子

这个例子是 kotlinx.coroutines 的第一个小例子。

fun main(args: Array<String>) { 
    launch(CommonPool) { // create new coroutine in common thread pool 
        delay(1000L) // non-blocking delay for 1 second (default time unit is ms) 
        println("World!") // print after delay 
    } 
    println("Hello,") // main function continues while coroutine is delayed 
    Thread.sleep(2000L) // block main thread for 2 seconds to keep JVM alive 
} 

这个例子的运行结果是：

Hello, 
World! 

其实有了上一篇文章的基础我们很容易知道，launch 方法启动了一个协程，CommonPool 是一个有线程池的上下文，它可以负责把协程的执行分配到合适的线程上。所以从线程的角度来看，打印的这两句是在不同的线程上的。

20170206-063015.015 [main] Hello, 
20170206-063016.016 [ForkJoinPool.commonPool-worker-1] World! 

这段代码的执行效果与线程的版本看上去是一样的：

thread(name = "MyThread") {  
    Thread.sleep(1000L)  
    log("World!")  
} 
log("Hello,")  
Thread.sleep(2000L)  

3. 主线程上的协程

我们刚才通过 launch 创建的协程是在 CommonPool 的线程池上面的，所以协程的运行并不在主线程。如果我们希望直接在主线程上面创建协程，那怎么办？

fun main(args: Array<String>) = runBlocking<Unit> {  
    launch(CommonPool) {  
        delay(1000L) 
        println("World!") 
    } 
    println("Hello,")  
    delay(2000L)  
} 

这个还是 kotlinx.coroutines 的例子，我们来分析一下。runBlocking 实际上也跟 launch 一样，启动一个协程，只不过它传入的 context 不会进行线程切换，也就是说，由它创建的协程会直接运行在当前线程上。

在 runBlocking 当中通过 launch 再创建一个协程，显然，这段代码的运行结果与上一个例子是完全一样的。需要注意的是，尽管我们可以在协程中通过 launch 这样的方法创建协程，但不要再协程当中通过 runBlocking 再来创建协程，因为这样做虽然一般来说不会导致程序异常，不过，这样的程序也没有多大意义：

fun main(args: Array<String>) = runBlocking<Unit> { 
    runBlocking { 
        delay(1000L) 
        println("World!") 
    } 
    println("Hello,") 
} 

运行结果：

World! 
Hello, 

大家看到了，嵌套的 runBlocking 实际上仍然只是一段顺序代码而已。

那么，让我们再仔细看看前面的例子，不知道大家有没有问题：如果我在 launch 创建的协程当中多磨叽一会儿，主线程上的协程 delay(2000L) 好像也没多大用啊。有没有什么方法保证协程执行完？

4. 外部控制协程

我们在上一篇文章当中只是对内置的基础 API 进行了简单的封装，而 kotlinx.coroutines 却为我们做了非常多的事情。比如，每一个协程都看做一个 Job，我们在一个协程的外部也可以控制它的运行。

fun main(args: Array<String>) = runBlocking<Unit> { 
    val job = launch(CommonPool) {  
        delay(1000L) 
        println("World!") 
    } 
    println("Hello,") 
    job.join()  
} 

job.join 其实就是要求当前协程等待 job 执行完成之后再继续执行。

其实，我们还可以取消协程，让他直接停止执行：

fun main(args: Array<String>) = runBlocking<Unit> { 
    val job = launch(CommonPool) {  
        delay(1000L) 
        println("World!") 
    } 
    println("Hello,") 
    job.cancel()  
} 

job.cancel 会直接终止 job 的执行。如果 job 已经执行完毕，那么 job.cancel 的执行时没有意义的。我们也可以根据 cancel 的返回值来判断是否取消成功。

另外，cancel 还可以提供原因：

job.cancel(IllegalAccessException("World!")) 

如果我们提供了这个原因，那么被取消的协程会将它打印出来。

Hello, 
Exception in thread "main" java.lang.IllegalAccessException: World! 
    at example13.Example_13Kt$main$1.doResume(example-13.kt:14) 
    at kotlin.coroutines.experimental.jvm.internal.CoroutineImpl.resume(CoroutineImpl.kt:53) 
    at kotlinx.coroutines.experimental.DispatchedContinuation$resume$1.run(CoroutineDispatcher.kt:57) 

其实，如果你自己做过对线程任务的取消，你大概会知道除非被取消的线程自己去检查取消的标志位，或者被 interrupt，否则取消是无法实现的，这有点儿像一个人执意要做一件事儿，另一个人说你别做啦，结果人家压根儿没听见，你说他能停下来吗？那么我们前面的取消到底是谁去监听了这个 cancel 操作呢？

当然是 delay 这个操作了。其实所有 kotlinx.coroutines 当中定义的操作都可以做到这一点，我们对代码稍加改动，你就会发现异常来自何处了：

val job = launch(CommonPool) {  
    try { 
        delay(1000L) 
        println("World!") 
    } catch(e: Exception) { 
        e.printStackTrace() 
    }finally { 
        println("finally....") 
    } 
} 
println("Hello,") 
job.cancel(IllegalAccessException("World!"))  

是的，你没看错，我们居然可以在协程里面对 cancel 进行捕获，如果你愿意的话，你甚至可以继续在这个协程里面运行代码，但请不要这样做，下面的示例破坏了 cancel 的设计本意，所以请勿模仿：

val job = launch(CommonPool) {  
    try { 
        ... 
    }finally { 
        println("finally....") 
    } 
    println("I'm an EVIL!!! Hahahaha") 
} 

说这个是什么意思呢？在协程被 cancel 掉的时候，我们应该做的其实是把战场打扫干净，比如：

val job = launch(CommonPool) { 
    val inputStream = ...
    try {
        ...
    }finally {
        inputStream.close()
    }
}

我们再来考虑下面的情形：

fun main(args: Array<String>) = runBlocking<Unit> { 
    val job = launch(CommonPool) { 
        var nextPrintTime = 0L 
        var i = 0 
        while (true) { // computation loop 
            val currentTime = System.currentTimeMillis() 
            if (currentTime >= nextPrintTime) { 
                println("I'm sleeping ${i++} ...") 
                nextPrintTime = currentTime + 500L 
            } 
        } 
    } 
    delay(1300L) // delay a bit 
    println("main: I'm tired of waiting!") 
    job.cancel() // cancels the job 
    delay(1300L) // delay a bit to see if it was cancelled.... 
    println("main: Now I can quit.") 
} 

不得不说，kotlinx.coroutines 在几天前刚刚更新的文档和示例非常的棒。我们看到这个例子，while(true) 会让这个协程不断运行来模拟耗时计算，尽管外部调用了 job.cancel()，但由于内部并没有 care 自己是否被 cancel，所以这个 cancel 显然有点儿失败。如果你想要在类似这种耗时计算当中检测当前协程是否被取消的话，你可以这么写：

... 
while (isActive) { // computation loop 
   ... 
} 
...       

isActive 会在 cancel 之后被置为 false。

其实，通过这几个示例大家就会发现协程的取消，与我们通常取消线程操作的思路非常类似，只不过人家封装的比较好，而我们呢，每次还得自己搞一个 CancelableTask 来实现 Runnable 接口去承载自己的异步操作，想想也是够原始呢。

5. 轻量级线程

协程时轻量级的，它拥有自己的运行状态，但它对资源的消耗却非常的小。其实能做到这一点的本质原因，我们已经在上一篇文章当中提到过，一台服务器开 1k 线程和 1k 协程来响应服务，前者对资源的消耗必然很大，而后者可能只是基于很少的几个或几十个线程来工作的，随着请求数量的增加，协程的优势可能会体现的更加明显。

我们来看个比较简单的例子：

fun main(args: Array<String>) = runBlocking<Unit> { 
    val jobs = List(100_000) {  
        launch(CommonPool) { 
            delay(1000L) 
            print(".") 
        } 
    } 
    jobs.forEach { it.join() } //这里不能用 jobs.forEach(Job::join)，因为 Job.join 是 suspend 方法 
} 

通过 List 这个方法，我们可以瞬间创建出很多对象放入返回的 List，注意到这里的 jobs 其实就是协程的一个 List。

运行上面的代码，我们发现 CommonPool 当中的线程池的线程数量基本上维持在三四个就足够了，如果我们用线程来写上面的代码会是什么感觉？

fun main(args: Array<String>) = runBlocking<Unit> { 
    val jobs = List(100_000) {  
        thread { 
            Thread.sleep(1000L) 
            log(".") 
        } 
    } 
    jobs.forEach(Thread::join) // Thread::join 说起来也是 1.1 的新特性呢！ 
}  

运行时，在创建了 1k 多个线程之后，就抛出了异常：

Exception in thread "main" java.lang.OutOfMemoryError: unable to create new native thread 
    at java.lang.Thread.start0(Native Method) 

嗯，又多了一个用协程的理由，对不对？

6. 携带值的 Job

我们前面说了，通过携程返回的 Job，我们可以控制携程的运行。可有时候我们更关注协程运行的结果，比如从网络加载一张图片：

suspend fun loadImage(url: String): Bitmap { 
    ... 
    return ... 
} 

没错，我们更关注它的结果，这种情况我们该怎么办呢？如果 loadImage 不是 suspend 方法，那么我们在非 UI 线程当中直接获取他们：

val imageA = loadImage(urlA) 
val imageB = loadImage(urlB) 
onImageGet(imageA, imageB) 

这样的操作有什么问题？顺序获取两张图片，耗时，不经济。所以传统的做法就是开两个线程做这件事儿，这意味着你会看到两个回调，并且还要同步这两个回调，想想都头疼。

不过我们现在有更好的办法：

val imageA = defer(CommonPool) { loadImage(urlA) } 
val imageB = defer(CommonPool) { loadImage(urlB) } 
onImageGet(imageA.await(),imageB.await()) 

代码量几乎没有增加，不过我们却做到了两张图片异步获取，并同时传给 onImageGet 以便继续后面的操作。

defer 到底是个什么东西？其实大家大可不必看到新词就感到恐慌，这东西用法几乎跟 launch 一样，只不过它返回的 Deferred 功能比 Job 多了一样：携带返回值。我们前面看到的 imageA 其实就是一个 Deferred 实例，而它的 await 方法返回的则是 Bitmap 类型，也即 loadImage(urlA) 的返回值。

所以如果你对协程运行的结果感兴趣，直接使用 defer 来替换你的 launch 就可以了。需要注意的是，即便你不调用 await，defer 启动的协程也会立即运行，如果你希望你的协程能够按需启动，例如只有你调用 await 之后再启动，那么你可以用 lazyDefer：

val imageA = lazyDefer(CommonPool) { loadImage(urlA) } 
val imageB = lazyDefer(CommonPool) { loadImage(urlB) } 
onImageGet(imageA.await(),imageB.await()) //这时候才开始真正去加载图片 

7. 生成器

不知道大家对 python 的生成器有没有了解，这个感觉就好似延迟计算一样。

假设我们要计算 fibonacci 数列，这个大家都知道，也非常容易写，你可能分分钟写出一个递归的函数来求得这个序列，不过你应该知道递归的层级越多，stackOverflow 的可能性越大吧？另外，如果我们只是用到其中的几个，那么递归的函数一下子都给求出来，而且每次调用也没有记忆性导致同一个值计算多次，非常不经济。大家看一个 python 的例子：

def fibonacci(): 
    yield 1 # 直接返回 1， 并且在此处暂停 
    first = 1 
    second = 1 
    while True: 
        yield first 
        first, second = first + second, first 

a = fibonacci() 
for x in a: 
    print x 
    if x > 100: break 

前面给出的这种计算方法，fibonacci 函数返回一个可迭代的对象，这个对象其实就是生成器，只有我们在迭代它的时候，它才会去真正执行计算，只要遇到 yield，那么这一次迭代到的值就是 yield 后面的值，比如，我们第一次调用 fibonacci 这个函数的时候，得到的值就是 1，后面依次类推。

Kotlin 在添加了协程这个功能之后，也可以这么搞了：

val fibonacci = buildSequence { 
    yield(1) // first Fibonacci number 
    var cur = 1 
    var next = 1 
    while (true) { 
        yield(next) // next Fibonacci number 
        val tmp = cur + next 
        cur = next 
        next = tmp 
    } 
} 
... 
for (i in fibonacci){ 
    println(i) 
    if(i > 100) break //大于100就停止循环 
} 

可以这么说，这段代码与前面的 python 版本功能是完全相同的，在 yield 方法调用时，传入的值就是本次迭代的值。

fibonacci 这个变量的类型如下：

public interface Sequence<out T> { 
   public operator fun iterator(): Iterator<T> 
} 

既然有 iterator 方法，那么我们可以直接对 fibonacci 进行迭代也就没什么大惊小怪的了。这个 iterator 保证每次迭代的时候去执行 buildSequence 后面的 Lambda 的代码，从上一个 yield 之后开始到下一个 yield 结束，yield 传入的值就是 iterator 的 next 的返回值。

有了这个特性，我们就可以构造许多“懒”序列，只有在用到的时候才去真正计算每一个元素的值，而且运算状态可以保存，每次计算的结果都不会浪费。

注：这个特性是被 Kotlin 标准库收录了的，并不存在于 kotlinx.coroutines 当中，不过这也没关系啦，kotlinx.coroutines 的 API 会不会在不久的将来也作为 Kotlin 标准库的内容出现呢？

8. 小结

这一篇的内容其实相对上一篇要简单一些，面对 kotlinx.coroutines 这样的框架，我们直接通过分析案例，将 coroutine 这么理论化的东西投入实际场景，让大家从感性上对其有个更加深入的认识。

当然，我们并没有深入其中了解其原理，原因就是上一篇我们为此做了足够的准备 —— kotlinx.coroutines 作为官方的框架，自然要实现得完善一些，但也是万变不离其宗。

写到这里，我想，我们还是需要有一篇文章再来介绍一些协程使用的一些注意事项，那么我们下一篇再见吧。