1 它是什么（协程和 Kotlin协程）

1.1 协程是什么

维基百科：协程，英文Coroutine [kəru’tin] （可入厅），是计算机程序的一类组件，推广了协作式多任务的子程序，允许执行被挂起与被恢复。

作为Google钦定的Android开发首选语言Kotlin，协程并不是 Kotlin 提出来的新概念，目前有协程概念的编程语言有Lua语言、Python语言、Go语言、C语言等，它只是一种编程思想，不局限于特定的语言。

而每一种编程语言中的协程的概念及实现又不完全一样，本次分享主要讲Kotlin协程。

1.2 Kotlin协程是什么

Kotlin官网：协程是轻量级线程

可简单理解：一个线程框架，是全新的处理并发的方式，也是Android上方便简化异步执行代码的方式

类似于 Java：线程池 Android：Handler和AsyncTask，RxJava的Schedulers

注：Kotlin不仅仅是面向JVM平台的，还有JS/Native，如果用kotlin来写前端，那Koltin的协程就是JS意义上的协程。如果仅仅JVM 平台，那确实应该是线程框架。

1.3 进程、线程、协程比较

可通过以下两张图理解三者的不同和关系

2 为什么选择它（协程解决什么问题）

异步场景举例：

第一步：接口获取当前用户token及用户信息
第二步：将用户的昵称展示界面上
第三步：然后再通过这个token获取当前用户的消息未读数
第四步：并展示在界面上

2.1 现有方案实现

1apiService.getUserInfo().enqueue(object :Callback<User>{
2    override fun onResponse(call: Call<User>, response: Response<User>) {
3        val user = response.body()
4        tvNickName.text = user?.nickName
5        apiService.getUnReadMsgCount(user?.token).enqueue(object :Callback<Int>{
6            override fun onResponse(call: Call<Int>, response: Response<Int>) {
7                val tvUnReadMsgCount = response.body()
8                tvMsgCount.text = tvUnReadMsgCount.toString()
9            }
10        })
11    }
12})

现有方案如何拿到异步任务的数据，得不到就毁掉哈哈哈，就是通过回调函数来解决。
若嵌套多了，这种画风是不是有点回调地狱的感觉，俗称的「callback hell」

2.2 协程实现

1mainScope.launch {
2    val user = apiService.getUserInfoSuspend() //IO线程请求数据
3    tvNickName.text = user?.nickName //UI线程更新界面
4    val unReadMsgCount = apiService.getUnReadMsgCountSuspend(user?.token) //IO线程请求数据
5    tvMsgCount.text = unReadMsgCount.toString() //UI线程更新界面
6}

1suspend fun getUserInfoSuspend() :User? {
2    return withContext(Dispatchers.IO){
3        //模拟网络请求耗时操作
4        delay(10)
5        User("asd123", "userName", "nickName")
6    }
7}
8
9suspend fun getUnReadMsgCountSuspend(token:String?) :Int{
10    return withContext(Dispatchers.IO){
11        //模拟网络请求耗时操作
12        delay(10)
13        10
14    }
15}

红色框框内的就是一个协程代码块。

可以看得出在协程实现中告别了callback，所以再也不会出现回调地狱这种情况了，协程解决了回调地狱

协程可以让我们用同步的代码写出异步的效果，这也是协程最大的优势，异步代码同步去写。

小结：协程可以异步代码同步去写，解决回调地狱，让程序员更方便地处理异步业务，更方便地切线程，保证主线程安全。

它是怎么做到的？

3 它是怎么工作的（协程的原理浅析）

3.1 协程的挂起和恢复

挂起（非阻塞式挂起）

suspend 关键字，它是协程中核心的关键字，是挂起的标识。

下面看一下上述示例代码切换线程的过程：

每一次从主线程切到IO线程都是一次协程的挂起操作；

每一次从IO线程切换主线程都是一次协程的恢复操作；

挂起和恢复是suspend函数特有的能力，其他函数不具备，挂起的内容是协程，不是挂起线程，也不是挂起函数，当线程执行到suspend函数的地方，不会继续执行当前协程的代码了，所以它不会阻塞线程，是非阻塞式挂起。

有挂起必然有恢复流程，恢复是指将已经被挂起的目标协程从挂起之处开始恢复执行。在协程中，挂起和恢复都不需要我们手动处理，这些都是kotlin协程帮我们自动完成的。

那Kotlin协程是如何帮我们自动实现挂起和恢复操作的呢？

它是通过Continuation来实现的。 [kənˌtɪnjuˈeɪʃ(ə)n] （继续；延续；连续性；后续部分）

3.2 协程的挂起和恢复的工作原理（Continuation）

CPS + 状态机

Java中没有suspend函数，suspend是Kotlin中特有的关键字，当编译时，Kotlin编译器会将含有suspend关键字的函数进行一次转换。

这种被编译器转换在kotlin中叫CPS转换（cotinuation-passing-style）。

转换流程如下所示

程序员写的挂起函数代码：

1suspend fun getUserInfo() : User {
2    val user = User("asd123", "userName", "nickName")
3    return user
4}

假想的一种中间态代码（便于理解）：

1fun getUserInfo(callback: Callback<User>): Any? {
2    val user = User("asd123", "userName", "nickName")
3    callback.onSuccess(user)
4    return Unit
5}

转换后的代码：

1fun getUserInfo(cont: Continuation<User>): Any? {
2    val user = User("asd123", "userName", "nickName")
3    cont.resume(user)
4    return Unit
5}

我们通过Kotlin生成字节码工具查看字节码，然后将其反编译成Java代码：

1@Nullable
2public final Object getUserInfo(@NotNull Continuation $completion) {
3   User user = new User("asd123", "userName", "nickName");
4   return user;
5}

这也验证了确实是会通过引入一个Continuation对象来实现恢复的流程，这里的这个Continuation对象中包含了Callback的形态。

它有两个作用：1. 暂停并记住执行点位；2. 记住函数暂停时刻的局部变量上下文。

所以为什么我们可以用同步的方式写异步代码，是因为Continuation帮我们做了回调的流程。

下面看一下这个Continuation 的源码部分

可以看到这个Continuation中封装了一个resumeWith的方法，这个方法就是恢复用的。

1internal abstract class BaseContinuationImpl() : Continuation<Any?> {
2
3
4    public final override fun resumeWith(result: Result<Any?>) {
5        //省略好多代码
6        invokeSuspend()
7        //省略好多代码
8    }
9
10
11    protected abstract fun invokeSuspend(result: Result<Any?>): Any?
12}
13
14
15internal abstract class ContinuationImpl(
16    completion: Continuation<Any?>?,
17    private val _context: CoroutineContext?
18) : BaseContinuationImpl(completion) {
19
20protected abstract fun invokeSuspend(result: Result<Any?>): Any?
21
22//invokeSuspend() 这个方法是恢复的关键一步

继续看上述例子：

这是一个CPS之前的代码：

1suspend fun testCoroutine() {
2    val user = apiService.getUserInfoSuspend() //挂起函数  IO线程
3    tvNickName.text = user?.nickName //UI线程更新界面
4    val unReadMsgCount = apiService.getUnReadMsgCountSuspend(user?.token) //挂起函数  IO线程
5    tvMsgCount.text = unReadMsgCount.toString() //UI线程更新界面
6}

当前挂起函数里有两个挂起函数

通过kotlin编译器编译后：

1fun testCoroutine(completion: Continuation<Any?>): Any? {
2    // TestContinuation本质上是匿名内部类
3    class TestContinuation(completion: Continuation<Any?>?) : ContinuationImpl(completion) {
4        // 表示协程状态机当前的状态
5        var label: Int = 0
6
7
8        // 两个变量，对应原函数的2个变量
9        lateinit var user: Any
10        lateinit var unReadMsgCount: Int
11
12
13        // result 接收协程的运行结果
14        var result = continuation.result
15
16
17        // suspendReturn 接收挂起函数的返回值
18        var suspendReturn: Any? = null
19
20
21        // CoroutineSingletons 是个枚举类
22        // COROUTINE_SUSPENDED 代表当前函数被挂起了
23        val sFlag = CoroutineSingletons.COROUTINE_SUSPENDED
24
25
26        // invokeSuspend 是协程的关键
27        // 它最终会调用 testCoroutine(this) 开启协程状态机
28        // 状态机相关代码就是后面的 when 语句
29        // 协程的本质，可以说就是 CPS + 状态机
30        override fun invokeSuspend(_result: Result<Any?>): Any? {
31            result = _result
32            label = label or Int.Companion.MIN_VALUE
33            return testCoroutine(this)
34        }
35    }
36
37
38    // ...
39    val continuation = if (completion is TestContinuation) {
40        completion
41    } else {
42        //                作为参数
43        //                   ↓
44        TestContinuation(completion)

1loop = true
2while(loop) {
3when (continuation.label) {
4    0 -> {
5        // 检测异常
6        throwOnFailure(result)
7
8
9        // 将 label 置为 1，准备进入下一次状态
10        continuation.label = 1
11
12
13        // 执行 getUserInfoSuspend（第一个挂起函数）
14        suspendReturn = getUserInfoSuspend(continuation)
15
16
17        // 判断是否挂起
18        if (suspendReturn == sFlag) {
19            return suspendReturn
20        } else {
21            result = suspendReturn
22            //go to next state
23        }
24    }
25
26
27    1 -> {
28        throwOnFailure(result)
29
30
31        // 获取 user 值
32        user = result as Any
33
34
35        // 准备进入下一个状态
36        continuation.label = 2
37
38
39        // 执行 getUnReadMsgCountSuspend
40        suspendReturn = getUnReadMsgCountSuspend(user.token, continuation)
41
42
43        // 判断是否挂起
44        if (suspendReturn == sFlag) {
45            return suspendReturn
46        } else {
47            result = suspendReturn
48            //go to next state
49        }
50    }
51
52
53    2 -> {
54        throwOnFailure(result)
55
56
57        user = continuation.mUser as Any
58        unReadMsgCount = continuation.unReadMsgCount as Int
59        loop = false
60}
61}

通过一个label标签控制分支代码执行,label为0,首先会进入第一个分支,首先将label设置为下一个分支的数值,然后执行第一个suspend方法并传递当前Continuation,得到返回值,如果是COROUTINE SUSPENDED,协程框架就直接return,协程挂起,当第一个suspend方法执行完成,会回调Continuation的invokeSuspend方法,进入第二个分支执行,以此类推执行完所有suspend方法。

每一个挂起点和初始挂起点对应的 Continuation 都会转化为一种状态，协程恢复只是跳转到下一种状态中。挂起函数将执行过程分为多个 Continuation 片段，并且利用状态机的方式保证各个片段是顺序执行的。

小结：协程的挂起和恢复的本质是CPS + 状态机

4 总结

总结几个不用协程实现起来很麻烦的骚操作：

如果有一个函数，它的返回值需要等到多个耗时的异步任务都执行完毕返回之后，组合所有任务的返回值作为最终返回值
如果有一个函数，需要顺序执行多个网络请求，并且后一个请求依赖前一个请求的执行结果
当前正在执行一项异步任务，但是你突然不想要它执行了，随时可以取消
如果你想让一个任务最多执行3秒，超过3秒则自动取消

Kotlin协程之所以被认为是假协程，是因为它并不在同一个线程运行，而是真的会创建多个线程。

Kotlin协程在Android上只是一个类似线程池的封装，真就是一个线程框架。但是它却可以让我们用同步的代码风格写出异步的效果，至于怎么做的，这个不需要我们操心，这些都是kotlin帮我们处理好了，我们需要关心的是怎么用好它

它就是一个线程框架。

作者：京东物流王斌

来源：京东云开发者社区自猿其说Tech 转载请注明来源

Android Kotlin 协程初探 | 京东物流技术团队

1 它是什么（协程和 Kotlin协程）

1.1 协程是什么

1.2 Kotlin协程是什么

1.3 进程、线程、协程比较

2 为什么选择它（协程解决什么问题）

2.1 现有方案实现

2.2 协程实现

3 它是怎么工作的（协程的原理浅析）

3.1 协程的挂起和恢复

3.2 协程的挂起和恢复的工作原理（Continuation）

4 总结

评论区

相关推荐

Android Kotlin 协程初探 | 京东物流技术团队

1 它是什么（协程 和 Kotlin协程）

1.1 协程是什么

1.2 Kotlin协程是什么

1.3 进程、线程、协程比较

2 为什么选择它（协程解决什么问题）

2.1 现有方案实现

2.2 协程实现

3 它是怎么工作的（协程的原理浅析）

3.1 协程的挂起和恢复

3.2 协程的挂起和恢复的工作原理（Continuation）

4 总结

评论区

相关推荐

1 它是什么（协程和 Kotlin协程）