Kotlin 协程的使用

Kotlin 协程

协程（Coroutine）与线程（Thread）

协程和线程的区别

协程和线程的共同目的之一是实现系统资源的上下文调用，不过它们的实现层级不同；

线程（Thraed）是比进程小一级的的运行单位，多线程实现系统资源上下文调用，是编程语言交付系统内核来进行的（可能是并发，也可能是伪并发），大部分的编程语言的多线程实现都是抢占式的，而对于这些线程的控制，编程语言无法直接控制，需要通过系统内核来进行，由系统内核决定最终的行为；

协程（Coroutine）是在语言层面实现“多线程”这个过程，一般在代码中以串行的方式表达并发逻辑，由于是在编程语言层面模拟这一过程，而非涉及到硬件层面，在编程语言层面可以完全控制这一过程，可以这么说，协程是软件层面模拟硬件层面的多线程；但不是说协程就一定是单线程，具体的实现要看具体编程语言的实现，kotlin的协程实现可能是单线程，也可能是多线程；

协程的使用场景

协程可以用于解决高负荷网络 IO、文件 IO、CPU/GPU 密集型任务等；

比如在IO线程高负载的场景下，CPU资源会被大量线程占用，这会极大浪费CPU资源，同时可能导致一些重要的线程被阻塞，代价是十分昂贵的，此时如果使用IO协程代替IO线程，可以大大减少线程数量，节省CPU资源，同时在协程挂起是几乎无代价的（不需要上下文切换或OS干预），同时编程语言对协程又有极大控制性；

Kotlin 1.1 中使用协程

Kotlin 1.1 开始提供了对于协程的支持，不过目前 kotlin 1.1 版本的协程处于实验性阶段，相关的包不包含在标准库中，需要手动导入"kotlinx-coroutines-core"包到项目依赖，可以直接 maven 中央仓库找到最新的 jar 包；
如果是使用 gradle 构建项目，在 build.gradle 脚本中需要添加类似以下：

apply plugin: 'java'
apply plugin: 'kotlin'
......
dependencies {
    compile 'org.jetbrains.kotlinx:kotlinx-coroutines-core:0.19.1'    //添加相关包依赖
    ......
}
kotlin{             //开始协程实验性功能
    experimental{
        coroutines 'enable'  
    }
}

kotlin 对于协程提供了底层的API，同时提供了高级API方便使用，这里只介绍部分高级API的基本使用；

一个基本协程例子

import kotlinx.coroutines.experimental.CommonPool
import kotlinx.coroutines.experimental.delay
import kotlinx.coroutines.experimental.launch
​
fun main(args: Array<String>) {
    async(CommonPool) {    //创建一个协程
        delay(1000L)       //协程挂起
        log("World")
    }
    log("Hello,")
    Thread.sleep(2000L)      //主线程等待
}
​
//输出简要日志，以下例子使用了这个函数作简要日志输出，不再重复解释
fun log(message:String){ println( "[${Thread.currentThread().name}] $message") }

输出：

[main] Hello,
[ForkJoinPool.commonPool-worker-1] World

协程的创建

kotlin 中可以通过 async() 函数创建一个协程，该协程创建后立即运行，一个 async 中可以包含一个 使用"suspend" 关键字声明的挂起函数，或使用一个 lambda 表达式表示的匿名方法，如下：

import kotlinx.coroutines.experimental.*;
​
//async 使用suspend函数创建协程
fun main(args: Array<String>) {
    async(CommonPool) {  //协程创建
        foo()
    }
    log("Hello,")
    Thread.sleep(2000L)
}
suspend fun foo(){   //挂起函数
    delay(1000L)
    log("World")
}
​
//async 使用匿名函数创建协程
fun main(args: Array<String>) {
    async(CommonPool) {   //协程创建
        delay(1000L)
        log("World")
    }
    log("Hello,")
    Thread.sleep(2000L)
}

在主线程上创建协程

以上的示例都是在 CommonPool 公共线程池上创建协程的，在main主线程中创建协程，可以如下标记 main：

fun main(args: Array<String>) = runBlocking<Unit>{
    async(CommonPool)  {
        delay(1000L)
        log("World")
    }
    log("Hello,")
    delay(2000L) //此时main主线程也为协程，可以使用其他协程行为函数
}

 

协程的行为控制

kotlin 1.1 对于协程提供了以下常用的控制方法：
dely(millis:Long)：协程挂起
Deffered.join()：类似Thread.join
Deffered.cancel()：协程取消，可携带一个 Exception 实例作为参数，以在协程取消时抛出该异常，可以通过返回值判断协程是否取消成功
Deffered.await()：等待直接获取协程返回值

/*演示join()
 在调用job.join时，main协程会挂起，直到job执行结束*/
fun main(args: Array<String>) = runBlocking<Unit> {
    val job = async(CommonPool) {
        delay(1000L)
        log("World!")
    }
    log("Hello,")
    job.join()
}
/*output:
[main] Hello,
[ForkJoinPool.commonPool-worker-1] World! */
​
​
/*演示cancel() */
fun main(args: Array<String>) = runBlocking<Unit> {
    val job = async(CommonPool) {
        delay(1000L)
        log("World!")
    }
    log("Hello,")
    job.cancel()
}
/*output:
[main] Hello, */
​
​
/*演示await()
 以下示例演示了一个典型的异步过程，在执行work()之前，异步执行前置任务preWork1(),preWork2(),等待这两个
 任务完全执行结束后，再执行word()；
 如果使用多线程来编写，需要些大量的回调函数，协程提供了一种简洁的编写方式*/
fun main(args: Array<String>) = runBlocking {
    val job1 = async(CommonPool) { preWork1() }
    val job2 = async(CommonPool) { preWork2() }
    work(job1.await(),job2.await())
}
suspend fun preWork1():String{
    delay(3000L)   //模拟一个耗时任务
    return "job1:van ♂ yang"
}
suspend  fun preWork2():String{
    delay(1000L)   //模拟一个耗时任务
    return "job2:dark fantastic!"
}
fun work(str1:String,str2:String){
    println("$str1\n$str2")
}
/*output:
job1:van ♂ yang
job2:dark fantastic! */

延迟生成器

kotlin 协程还提供了类似 Python 的生成器协程函数 buildSequence，用于执行一个延迟计算队列；
一个典型的应用就是生成斐波那契数列，一般编写会用递归的方式来编写，但是假如递归层级过大，很容易造成栈溢出，同时假如需要多次不等值地调用，会造成同一个值被多次计算，比较浪费资源，buildSequence 采用协程的方式，在每次调用时进行增量计算，避免同一值的多次调用，示例如下：

fun main(args: Array<String>) {
​
    //斐波那契数列
    val fibonacci = buildSequence {
        yield(1) //返回第一个斐波那契数
        var cur = 1
        var next = 1
        while (true) {
            yield(next) // 返回下一个斐波那契数
            val tmp = cur + next
            cur = next
            next = tmp
        }
    }
    //取出>100的斐波那契数
    for (i in fibonacci){
        println(i)
        if(i > 100) break
    }
  
    //取出>500的斐波那契数，此时调用时 1-100 的斐波那契数是已经被延迟队列计算好的了
    for (i in fibonacci){
        println(i)
        if(i > 500) break
    }
}

协程和线程的对比示例

上面讲过协程很适合使用在高负荷IO、CPU密集型的场景，通过协程模拟并发的方式减少实际的线程数，已达到节省CPU资源的目的，以下2个示例分别创建 100,000 个线程和 100,000个协程模拟一个高负荷IO的场景：

创建 100,000 个线程

fun main(args: Array<String>) = runBlocking<Unit> {
    val jobs = List(100_000) {
        thread {
            Thread.sleep(2000L)   //模拟IO阻塞
            log("hello")
        }
    }
    jobs.forEach(Thread::join)
}

此时我的机器上创建了几千个线程后抛出栈溢出异常（-Xmx1024），同时CPU占满（i7-6700HQ）

创建 100,000 个协程

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

程序运行时只创建了不到10个线程，并没有栈溢出，相比之下，在这样的场景里更适合使用协程；