补篇协程:关键字suspend「挂起」的深入理解

本文链接：https://blog.youkuaiyun.com/qq_33552379/article/details/139565776

`suspend` 挂起的原理：

挂起函数是一种可以在不阻塞线程的情况下挂起和恢复执行的函数。在Kotlin中，我们可以使用suspend关键字来定义一个挂起函数。挂起函数只能在协程或其他挂起函数中调用。

被suspend修饰的函数,该函数就会挂起.挂起函数能够以与普通函数相同的⽅式获取参数和返回值，但它们只能从协同和其他挂起函数中调⽤。挂起suspend 函数 , 只能在协程体内部或者其它挂起函数(带有suspend ) 中调用 ;协程外部不允许使用挂起函数 ;

在协程中 , 执行挂起 Suspend 函数 ,通过调度器切换到IO子线程,做异步耗时操作,需要等到拿到返回数据值才能执行后面的逻辑，但我们又不希望阻塞当前线程（通常是主线程），因此最终必须实现某种消息传递的机制，让后台子线程做完耗时操作以后把数据结果传给主线程。

suspend fun requestToken(): String
suspend fun createPost(token: String, item: Item): Post
suspend fun processPost(post)

suspend fun postItem(item: Item) {
  val token = 🏹 requestToken()
  val post = 🏹 createPost(token, item)
  🏹 processPost(post)
}

suspend「挂起」的本质1

suspend挂起函数，就是把协程的原来的线程切出去继续执行其他的逻辑代码.同时切换一个新的IO线程做耗时操作,当这个IO线程的耗时操作完成结束,再把原来的线程恢复resume给自动切回来,更新UI

suspend「挂起」的对象就是其所在的协程。

使用 launch /async 函数启动一个协程, 当该协程中所在的当线程执行到该协程的 suspend 函数的时候，暂时不继续执行该协程这个代码快了。

通过调度器Dispatchers 让当前协程launch运行在主线程Dispatchers.Main
在协程launch的代码块中，如果当前主线程执行到了 suspend withContext函数这里的时候，该协程launch就被挂起了,并且当前协程launch的主线程执行权被掐断，
当执行suspend withContext 函数的时候,通过调度器Dispatchers 切换到指定的IO线程, 此时执行suspend withContext 函数里面的代码逻辑(网络请求,IO读写操作)
那么, 此时暂时就不再执行该协程launch内的 suspend withContext 函数下面剩余的其他代码逻辑了
当前协程launch被挂起时,那么就执行协程launch的代码块以最外层的其他逻辑代码
当suspend withContext函数执行完成之后，协程launch会自动帮我们从IO线程再切回来到原来主线程,
那么当前协程launc的主线程就会恢复resume执行, 就会继续执行下面的代码:更新UI

suspend「挂起」关键字的缺陷

class SuspendActivity  : ComponentActivity() {

 override   fun onCreate(savedInstanceState: Bundle?){

 runBlocking {
            suspendTest() //输出的结果还是在主线程。
        }
      /**
      * suspendTest()函数所在的当前线程: main
       输出的结果还是在主线程。这说明仅仅一个关键字suspend,它并不能把当前协程挂起，也不会切换线程。
       */
}

suspend fun  suspendTest(){
    Log.e(TAG, "suspendTest()函数所在的当前线程: ${Thread.currentThread().name} ")
}

}

通过以上小案例,我们发现这个关键字suspend,它并不能把当前协程挂起，也不会切换线程。

真正挂起协程这件事，是 Kotlin 的协程框架帮我们做的。

所以我们想要自己写一个自定义挂起函数，仅仅只加上 suspend 关键字是不行的，还需要函数内部直接或间接地调用到 Kotlin 协程框架自带的 suspend 函数(withContext)才行。

这个 suspend 关键字并不能把当前协程挂起，也不会切换线程,那它的作用是什么？suspend关键字其实只是一个提醒。

如果我们自定义一个 suspend 函数(没有直接或间接调用 Kotlin 自带的 suspend 函数)，那么该函数即不能把当前协程挂起，也不会切换线程,该自定义一个 suspend 函数只有一个效果：就是限制这个函数只能在协程里被调用，如果在非协程的代码中调用，就会编译不通过。

所以，我们自定义一个 suspend 函数，为了让它包含真正挂起的逻辑，要在它内部直接或间接调用 Kotlin 自带的 suspend 函数，你的这个自定义suspend 函数才是有意义的。

怎么自定义 suspend 函数？

什么时候需要自定义 suspend 函数

如果你的某个函数比较耗时，也就是要等的操作，那就把它写成 suspend 函数。这就是原则。

耗时操作一般分为两类：I/O 操作和 CPU 计算工作。比如文件的读写、网络交互、图片的模糊处理，都是耗时的，通通可以把它们写进 suspend 函数里。

另外这个「耗时」还有一种特殊情况，就是这件事本身做起来并不慢，但它需要等待，比如 5 秒钟之后再做这个操作。这种也是 suspend 函数的应用场景。

具体该怎么写自定义 suspend 函数

给自定义函数加上 suspend 关键字，然后使用官方的suspend withContext函数 把我的自定义suspend函数的内容给包住就可以了。

提到用 withContext是因为它在挂起函数里功能最简单直接：把线程自动切走和切回。

当然并不是只有 withContext 这一个函数来辅助我们实现自定义的 suspend 函数，比如还有一个挂起函数叫 delay，它的作用是等待一段时间后再继续往下执行代码。

什么是「非阻塞式挂起」

即在协程里遇到suspend挂起函数时,该协程会被挂起,但该协程是非阻塞式的, 因为这个suspend挂起函数切换出一个新的IO线程去做耗时操作,不会阻塞该协程的原来的线程的继续执行其他的逻辑代码.

为什么要讲非阻塞式挂起

协程只是在写法上「看起来阻塞」，其实是「非阻塞」的，因为在协程里面它做了很多工作，其中有一个就是帮我们切线程。切换一个新的IO线程做耗时操作,原来的线程的继续执行其他的逻辑代码.

从下面的例子可以看到，耗时操作和更新 UI 的逻辑像写单线程一样放在了一起，只是在外面包了一层协程。
而正是这个协程解决了原来我们单线程写法会卡线程这件事。

class SuspendActivity  : ComponentActivity() {
 val tv_name2:TextView? by lazy{findViewById<TextView>(R.id.tv_name2)}

 override   fun onCreate(savedInstanceState: Bundle?){

  GlobalScope.launch(context=Dispatchers.Main,
        block={
            //耗时操作
            val result: String =   mainViewModel.suspendingGetImage(id=1010)
            //更新 UI
            tv_name2?.text=result
        } )

     tv_name2?.text="wangjin"

        /** 从上面的例子可以看到，耗时操作和更新 UI 的逻辑像写单线程一样放在了一起，只是在外面包了一层协程。
         *  而正是这个协程解决了原来我们单线程写法会卡线程这件事。
         *
         * */

}


}



  suspend fun suspendingGetImage(id: Int=0):String = withContext(context=Dispatchers.IO,block={
        Log.e(TAG, " 执行suspend withContext 函数开始:网络请求")
        delay(10000) //模拟网络请求耗时10s
        Log.e(TAG, " 10s后,执行suspend withContext 函数结束")
        "大头像$id"
    })

阻塞的本质

首先，所有的代码本质上都是阻塞式的，而只有比较耗时的代码才会导致人类可感知的耗时等待，比如在主线程上做一个耗时 50 ms 的操作会导致界面卡掉几帧，这种是我们人眼能观察出来的，而这就是我们通常意义所说的「阻塞」。

suspend「挂起」的本质2:就是把suspend函数被编译器转换成一个带有泛型参数的CallBack回调的 Continuation 对象:

虽然我们写出来的挂起函数并没有任何 Callback 的逻辑，但是，当 Kotlin 编译器检测到 suspend 关键字修饰的函数以后，就会自动将挂起函数转换成Continuation 对象(Continuation 就是一个带有泛型参数的 CallBack函数回调)

suspend挂起函数的本质就是 Callback。只是 Kotlin 用了一个更加高大上的名字 Continuation。

❶编译器将suspend挂起函数转换成 CallBack 函数的过程，叫做 CPS 转换（Continuation-Passing-Style Transformation）。CPS就是将程序接下来要执行的代码进行传递的一种模式，CPS 转换，就是将原本的同步挂起函数转换成 CallBack 异步代码的过程

❷挂起函数在 CPS 转换过后，函数的类型会变成了 (Continuation) -> Any?

❸所以在 Java 中访问 Kotlin 挂起函数时，会看到它的参数是 Continuation，返回值是 Object

  // Continuation 本质上就是一个带有泛型参数的 CallBack回调
public interface Continuation<in T> {
  //上下文（Continuation Context）：绑定的执行环境。
  public val context: CoroutineContext

 /**
  用来回调的方法   
 携带结果并且恢复被挂起的协程，结果被封装在 Result 对象中，
可以是：Result .success（传值）回调、Result .failure（传异常）回调。
*/
  public fun resumeWith(result: Result<T>) 
}

Kotlin 编译器会给每个 suspend 的块生成一个 Continuation 的实现类，这个实现类是一个状态机，其中的状态对应于每个挂起点，保存了需要下一步继续执行所需要的上下文（即依赖的局部变量），类似下面的伪代码：

suspend fun postItem(item: Item) {
  val token =  requestToken()
  val post =   createPost(token, item)
    processPost(post)
}

// 编译器变换后的伪代码
// 1.脱掉了 suspend 关键字
// 2.增加了一个 Continuation 对象
fun postItem(item: Item, cont: Continuation) {

 // 判断传入的是否是 postItem 的 `ContiuationImpl`
  // * false: 初始化一个对应本次调用 postItem 的状态机
  // * true: 对应 postItem 内其他 suspend 函数回调回来情况

 // 其中 ThisSM 指的 object: ContinuationImpl 这个匿名类
val sm = (cont as? ThisSM) ?: object: ContinuationImpl {
    // 实际源码中 override 的是
    // kotlin.coroutine.jvm.internal.BaseContinuationImpl
    // 的 invokeSuspend 方法
  override fun resume(..) {
       // 通过 ContinuationImpl.resume
      // 重新回调回这个方法
       postItem(null, this) 
 }

}

 switch (sm.label) {
     case 0:
      // 捕获后续步骤需要的局部变量
       sm.item = item
      // 设置下一步的 label
       sm.label = 1
       // 当 requestToken 里的耗时操作完成后会更新状态机
      // 并通过 sm.resume 再次调用这个 postItem 函数
      // 「我们在前面提供了 sm.resume 的实现，即再次调用 postItem」
     requestToken(sm)
 
    case 1:
     val item = sm.item
     // 前一个异步操作的结果
      val token = sm.result as Token
      sm.label = 2
      createPost(token, item, sm)


     case 2:
      procesPost(post)
     // ...

}




}

Continuation 到底是指什么？

Continue 是继续的意思，Continuation 则是接下来要做的事情.放到程序中，Continuation 就代表了程序接下来要执行的代码，或者是剩下的代码

可以看到，当程序执行到 getUserInfo() 的时候，剩下的未执行代码都被一起打包了起来，以 Continuation 的形式，传递给了 getUserInfo() 的 Callback 回调当中。

以下就是 Kotlin 挂起函数的核心原理，它的挂起和恢复，其实也是通过 CPS 转换来实现的。

总结：协程之所以是非阻塞，是因为它支持挂起和恢复；而挂起和恢复的能力，主要是源自于挂起函数；而挂起函数是由 CPS 实现的，其中的 Continuation，本质上就是 Callback。

为什么挂起函数可以调用挂起函数，而普通函数不能调用挂起函数呢？

挂起函数之所以能在挂起函数中调用，是因为挂起函数最终都是在协程中被调用的，是协程提供了挂起函数运行的环境。

被调用的suspend挂起函数需要传入一个 Continuation(由suspend转换而来)参数，没有被 suspend 修饰的普通函数是没有 Continuation 参数的，所以被调用的挂起函数没有办法从普通函数中获取一个 Continuation。

使用 `suspend` 函数无须关心线程切换

suspend 提供了这样一个约定(Convention)：调用这个函数不会阻塞当前调用的线程。这对 UI 编程是非常有用的，因为 UI 的主线程需要不断相应各种图形绘制、用户操作的请求，如果主线程上有耗时操作会让其他请求无法及时响应，造成 UI 卡顿。

随着 Android 官方将协程作为推荐的异步方案，常见的异步场景如网络请求、数据库都已经有支持协程的库，可以设想未来 Android 开发的新人其实不太需要知道线程切换的细节，只需要直接在主线程调用封装好的 suspend 函数即可，切换线程应该被当成实现细节被封装掉而几乎变成「透明」的，这是协程的厉害之处。

`suspend` 的不仅仅是 IO

suspend 本身并不完全是线程切换，只不过异步 IO 在 Android 平台最终都得依托多线程来实现；而异步 IO 又是协程的主要应用场景。Android 开发者们已经见识过各种异步 IO 的 API（对线程切换情有独钟），这些 API 本质上都得依靠某种形式的回调，将异步 IO 的结果通知给主线程进行 UI 刷新。协程的 suspend 也是如此，只不过通过关键字的引入和编译器的支持，让我们可以用顺序、从上到下（sequential）的代码写出异步逻辑。不仅提升了代码可读性，还方便我们利用熟悉的条件、循环、try catch 等构造轻松地写出复杂的逻辑。

通过上面这些关于 Android UI、函数式编程以及一般编程等方面的不同例子可以看到，suspend 可以看成是回调的语法糖，其实和 IO、和线程切换并没有本质的关系。回过头来看 suspend 这个关键字在别的语言通常叫 async，而 Kotlin 叫 suspend 或许正暗示了 Kotlin 协程独特的设计并不限于 asynchrony，而有着更宽广的应用场景。