Kotlin协程：一个轻量级的线程框架。

参考视频，凯哥的Kotlin协程视频入坑三连：概述，挂起，非阻塞式。

如果没有特殊提及，文中所有“协程”均代表“Kotlin协程”,对其他语言并不适用

是什么 - 线程API

Kotlin协程是一套由Kotlin官方提供的线程API。

就像Java的Executor和Android的AsyncTask一样，Kotlin的协程也就是对thread相关的api做了一套封装，让我们可以方便的写出并发操作。

方便在哪 - 非阻塞式挂起

  • 非阻塞式：

    你可以用看似同步的方式，写出异步的代码。或者说可以把运行在不同线程的代码，写到同一个代码块中，如下：

    1
    2
    3
    4
    launch(Dispatchers.Main){
        val user = api.getUser() //网络请求：后台线程
        nameTv.text = user.name //更新UI：主线程
    }

    上面的代码分别运行在两个线程，这在Java中是无法做到的,哪怕你使用RxJava也只能写成这样：

    1
    2
    3
    api.getUser()
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(user -> nameTv.text = user.name);

    如果想用单纯的Java来解决就只能老老实实的写回调了。

  • 挂起

    挂起的意思就是：自动切线程。也就是,它的线程在切出去之后，能够自动切回来。

    以上面的代码为例，上下两行代码一个在网络线程，一个在UI线程，你没有写任何处理语句【类似rx中的ObserverOn】，Kotlin协程自动从网络线程切到了UI线程。

    当然，这也是Kotlin协程能写出”非阻塞式代码“的一个原因。

为什么

那么问题来了，协程如何知道你的代码什么时候切线程，又什么时候切回来。

suspend关键字

当Kotlin执行到带有suspend关键字的函数（即挂起函数）的时候，就会自动挂起(其实就是切个线程)。当挂起函数执行完毕之后，协程会自动的切回（resume）它原先的那个线程。

1
2
3
4
5
6
7
8
9
10
11
launch(Dispatchers.Main){
    val user = api.getUser() //执行完后自动切回到Dispatchers.Main线程
    nameTv.text = user.name //更新UI：主线程
}

suspend fun getUser(){
    withContext(Dispatchers.IO){
        //网络请求：后台线程
        ...
    }
}

这也就是为什么挂起函数只能在协程里（或另一个挂起函数里）被调用，否则，在其他地方调用的话Android studio会直接给你报错。

Eerror: Kotlin: Suspend functions are only allowed to be called from a coroutine or another suspend function

因为只有这样，Kotlin才知道你的函数执行完了之后，会返回到哪个线程。

suspend 只是提醒

当然，suspend只是起到了提醒的作用，其内部真正执行线程切换操作的是withContext函数，也称挂起函数。

也可以不用withContext，kotlin还有很多自带的挂起函数，他们都能挂起一个函数。如果你想写一个函数自己来实现挂起，那么你得在你的函数内部至少包裹一个Kotlin自带的挂起函数才可以。

所以，重点是，suspend只是一个提醒，并不能实现挂起。它是函数创建者对函数调用者的提醒，其目的是为了告诉调用者：我这是一个耗时函数，这个函数以挂起的方式被放在了后台运行，所以，请在协程里调用。

怎么用

什么时候用

一句话：当你执行的操作耗时的时候用。

比如：IO操作、网络操作、CPU大量计算、图片模糊、图片美化等操作，都可以加上suspend关键字提醒调用者，这是个耗时操作，应该放在协程里。

怎么用

很简单，就像上面代码展示的那样。加上suspend关键字后，里面用上withContext即可。

而withContext只是众多挂起函数中的一个，还有其他的挂起函数。比如repeat(重复)，delay(延时)等等。具体可见官网。

Kotlin协程真的比线程高效么

Kotlin的官方为了证明协程很轻，给了个栗子：

1
2
3
4
5
6
repeat(100_000) {
    launch {
        delay(1000L)
        print(".")
    }
}

它启动了 10 万个协程，并且在 5 秒钟后，每个协程都输出一个点。

并说明如果你用thread来实现，你的代码很可能会因内存不足而崩溃。

对比示例：崩溃

1
2
3
4
5
6
repeat(100_000) { // 启动大量的协程
    thread {
        Thread.sleep(5000L)
        print(".")
    }
}

有理有据，令人信服。

但其实Kotlin官方在这里偷换了概念，协程是一套基于thread的上层API，如果真要对比的话，也应该和Java中的Executor来对比：

1
2
3
4
5
6
7
8
val executor = Executors.newCachedThreadPool()
val task = Runnable {
    Thread.sleep(1000L)
    print(".")
}
repeat(100_100){
    executor.execute(task)
}

并且这里的delay()和Thread.sleep()比较，依然会出现协程的效率更高的情况，Kotlin中的delay操作对应Executor里的代码应该是Executors.newSingleThreadScheduledExecutor,所以应该这样对比：

1
2
3
4
5
6
7
val executor = Executors.newSingleThreadScheduledExecutor()
val task = Runnable {
    print(".")
}
repeat(100_100){
    executor.schedule(task,1,TimeUnit.SECONDS)
}

这样一来，用不用协程就完全没有区别了。

所以结论是，Kotlin协程依然只是一套上层的API框架，Kotlin协程的性能不可能超过正确使用Jav线程的，并没有网上谣传的那么神奇。

但是它确实让我们coding更加简洁优雅了。