Android Kotlin（6）之《协程1》

Android Kotlin第六篇 协程1。Kotlin系列源码在源码下载这里下载。我们一起来了解下Kotlin的协程，协程也是Kotlin重点，也许我有的地方没有写好，也欢迎大家提出问题，纠正问题。

当然协程目前还是实验性的，也就是说后续也许会有改动，应该改动不会太大，基本的都定了，不然就不会放出来了。

1、协程概念

一些 API 启动长时间运行的操作（例如网络 IO、文件 IO、CPU 或 GPU 密集型任务等），并要求调用者阻塞直到它们完成。协程提供了一种避免阻塞线程并用更廉价、更可控的操作替代线程阻塞的方法：协程挂起。

协程通过将复杂性放入库来简化异步编程。程序的逻辑可以在协程中顺序地表达，而底层库会为我们解决其异步性。该库可以将用户代码的相关部分包装为回调、订阅相关事件、在不同线程（甚至不同机器！）上调度执行，而代码则保持如同顺序执行一样简单。

2、协程挂起和线程阻塞的区别

协程及协程挂起：
协程是通过编译技术实现的，不需要虚拟机VM/操作系统OS的支持，通过相关代码来生效
协程的挂起几乎无代价，无需上下文切换或涉及OS
协程不能在随机指令中挂起,只能在挂起点挂起(调用标记函数)!

线程及线程阻塞：
线程/进程是需要虚拟机VM/操作系统OS的支持，通过调度CPU执行生效
线程阻塞的代价昂贵，尤其是在高负载的可以用线程很少，阻塞线程会导致一些重要的任务缺少可用线程而被延迟

2、挂起函数

特殊修饰符 suspend 的函数，会发生挂起，这样的函数称为挂起函数。挂起函数能够以与普通函数相同的方式获取参数和返回值，但它们只能从协程和其他挂起函数中调用。事实上，要启动协程，必须至少有一个挂起函数，例如：

  //挂起函数
    suspend fun test1() : String{
        log("3")
        delay(1000L)
         return "aaa"
    }

3、协程的简单实例

我们需要在build下dependencies里添加：

compile 'org.jetbrains.kotlinx:kotlinx-coroutines-core:0.17'

我们先建一个简单实例看看

  //建立一个简单的协程程序
    fun test2(){
        launch(CommonPool){
            delay(3000L)
            log("1")
        }
        log("2")
        Thread.sleep(2000L)//阻塞主线程2秒，以保持JVM的生命
    }

这里面：

launch(CommonPool) {} <-> thread {}
delay() <-> Thread.sleep()

注意：这里delay是不能使用到thread里的，毕竟launch(CommonPool) {}不能完全等于 thread {}
调用：

var h = CoroutinesGoKotlin()
        h.test2()
        h.log("结束")

当然这里我就随便命名了，后面所有的输出最后都是以“结束”为结束
输出：

08-01 15:44:01.435 26405-26405/com.xiaoqiang.kotlin I/test: 2
08-01 15:44:03.435 26405-26405/com.xiaoqiang.kotlin I/test: 结束
08-01 15:44:04.445 26405-26465/com.xiaoqiang.kotlin I/test: 1

runBlocking
官方为了方便大家在coroutine区分阻塞与非阻塞代码,而且减少使用Thread这种胖子,就推荐了以下的写法:

fun test3() = runBlocking<Unit>{//<Unit>可以省略
        launch(CommonPool){
            delay(3000L)
            log("1")
        }
        log("2")
    }

runBlocking为最高级的协程 (一般为主协程), 其他协程如launch {} 能跑在runBlocking (因为层级较低), 反过来不行。输出与上面的一样

等待完成
如果接下里的工作需要依赖于另外一个，我们可以使用join，让其等待launch的完成。当然join暂停功能是可以取消的，如果调用coroutine作业期间被取消或者完成，立即回复下面执行。

fun test4() = runBlocking<Unit>{
        var job = launch(CommonPool){
            delay(3000L)
            log("1")
        }
        log("2")
        job.join()
        log("3")
    }

输出：

08-01 15:50:24.216 2536-2536/com.xiaoqiang.kotlin I/test: 2
08-01 15:50:27.216 2536-2585/com.xiaoqiang.kotlin I/test: 1
08-01 15:50:27.216 2536-2536/com.xiaoqiang.kotlin I/test: 3
08-01 15:50:27.216 2536-2536/com.xiaoqiang.kotlin I/test: 结束

你会发现输出3必须要等待launch里执行完了才执行。
当然如果有两个需要协同工作，也可以如下写：

fun test5() = runBlocking<Unit>{
        var job1 = launch(CommonPool){
            log("job1 start")
            delay(3000,TimeUnit.MILLISECONDS)
            log("job1 end")
        }
        log("1")
        var job2 = launch(CommonPool) {
            log("job2 start,wait job1 end")
            job1.join()
            log("job2 end")
        }
        log("2")
        job2.join()
        log("3")
    }

输出：

08-01 15:53:58.876 6709-6709/com.xiaoqiang.kotlin I/test: 1
08-01 15:53:58.876 6709-6709/com.xiaoqiang.kotlin I/test: 2
08-01 15:53:58.876 6709-6761/com.xiaoqiang.kotlin I/test: job1 start
08-01 15:53:58.876 6709-6765/com.xiaoqiang.kotlin I/test: job2 start,wait job1 end
08-01 15:54:01.876 6709-6765/com.xiaoqiang.kotlin I/test: job1 end
08-01 15:54:01.876 6709-6765/com.xiaoqiang.kotlin I/test: job2 end
08-01 15:54:01.876 6709-6709/com.xiaoqiang.kotlin I/test: 3
08-01 15:54:01.876 6709-6709/com.xiaoqiang.kotlin I/test: 结束

job2部分依赖于job1，这样你就可以让job1与job2协同工作

提取函数
如果launch(CommonPool){}里面代码很多，我们可以提取出来，用suspend修饰，成为暂停函数，如下：

suspend fun downUrl(){
        delay(3000L)
        log("1")
    }
    fun test6() = runBlocking<Unit>{
        var job = launch(CommonPool){
            downUrl()
        }
        log("2")
    }

协同程序是轻量级的
举个例子，你可以运行下面的程序：

fun test7() = runBlocking<Unit> {
        val jobs = List(100_00) {
            launch(CommonPool) {
                delay(1000L)
                log(".")
            }
        }
        jobs.forEach { it.join() }
    }

它启动了10K的coroutines，在一秒钟后，每个coroutine打印了一个点。你会发现你的内存几乎变化不大，当然太大了的话，也许你会遇到内存不足的错误，但是10K已经非常非常的多了。

Coroutines就像守护线程
我们也可以创建一个长时间工作的Coroutines，例如：

fun test8() = runBlocking<Unit>{
        launch(CommonPool) {
            repeat(1000) { i ->
                log("$i ...")
                delay(500L)
            }
        }
    }

每500毫秒打印一个，循环1000次。

谢谢大家的观赏，最近看了很多关于协程，一直不知道怎么写好，看了很多也实验了很多也想了很多，最后还是参照了官方的Github，因为我觉得这里面介绍的已经非常详细了，里面也有很多其他介绍的，推荐大家去看看，非常好的。如果我有没有写好的地方欢迎大家提出，谢谢！

协程还有很多需要我们区学习，当你真的学会协程你会发现其真的很好用，让异步的代码看起来更像是同步，非常好用的

最近也许我会有一次工作的大更换（换城市），更新会缓慢些，等工作回复后，我会加快更新。
全套源码下载这里源码会随着后面发布的Kotlin逐渐完善

a