Kotlin的协程究竟是什么——它便是个线程结构。没什么说不清的，就这么简略，它便是一个线程结构，只不过这个线程结构比较方便——其他呢，上一篇文章留下了一个大问号：协程最中心的那个「非堵塞式」的「挂起」究竟是怎样回事？

回顾一下上一期的常识点：

• 协程究竟是什么
• 协程究竟好在哪里
• 协程详细怎样用

大部分情况下，咱们都是用launch函数来创立协程，其实还有其他两个函数也能够用来创立协程：

• runBlocking
• async

runBlocking一般适用于单元测试的场景，而业务开发中不会用到这个函数，由于它是线程堵塞的。

接下来咱们主要来比照launch与async这两个函数。

• 相同点：它们都能够用来发动协程，回来的都是Coroutine,咱们这儿不需求纠结详细是回来哪个类。
• 不同点：async回来的Coroutine多完成了Deferred接口。

关于Deferred更深入的常识就不在这儿过多阐述，它的意思便是推迟，也便是成果稍后才干拿到。

咱们调用Deferred.await()就能够得到成果了。

接下来咱们持续看看async是如何运用的，先回忆一下上期中获取头像的场景：

coroutineScope.launch(Dispatchers.Main) {
    //async函数发动新的协程
    val avatar: Deferred = async { api.getAvatar(user) } // 获取用户头像
    val logo: Deferred = async { api.getCompanyLogo(user) }// 获取用户地点公司的logo
    // 获取回来值
    show(avatar.await(), logo.await())// 更新UI
}

能够看到avatar和logo的类型能够声明为Deferred,经过await获取成果并且更新到UI上显示。

await函数签名如下：

public suspeng fun await(): T

前面有个关键字是之前没有见过——suspend，这个关键字就对应了上期最后咱们留下的一个问号：协程最中心的那个「非堵塞式」的「挂起」究竟是怎样回事？

所以接下来，咱们的中心内容便是来好好说一说这个「挂起」。

「挂起」的本质

协程中「挂起」的目标究竟是什么？挂起线程，仍是挂起函数？都不对，咱们挂起的目标是协程。

还记得协程是什么吗？发动一个协程能够运用launch或许async函数，协程其实便是这两个函数中闭包的代码块。

launch,async或许其他函数创立的协程，在履行到某一个suspend函数的时分，这个协程会被「suspend」，也便是被挂起。

那此时又是从哪里挂起？从当前线程挂起。话句话说哦，便是这个协程咋整在履行它的线程上脱离。

注意，不是在这个协程停下来了！是脱离，当前线程不再管这个协程要去做什么了。

suspend是有暂停的意思，但咱们在协程中应该了解：当线程履行到协程的suspend函数的时分，暂时不持续履行协程代码了。

咱们让时间停止，然后兵分两路，分别看看这两个相互脱离的线程和写成接下来将会产生什么作业：

线程：
前面咱们说到，挂起会让协程正在履行它的线程上脱离，详细到代码其实是：
协程的代码块中，线程履行到了suspend函数这儿的时分，就暂时不再履行剩余的协程代码，调出协程的代码块。

那线程接下来会做什么呢？
假如它是一个后台线程？

• 要么无事可做，被系统收回
• 要么持续履行其他后台使命

跟Java线程池里的线程在作业完毕之后是彻底相同的：收回或许再利用。

假如这个线程它是Android的主线程，那么接下来就会持续回去作业：也便是一秒钟60次的界面改写使命。

一个常见的场景是，获取一个图片，然后显示出来：

// 主线程中
GlobalScope.launch(Dispatchers.Main) {
    val image = suspendingGetImage(imageId)// 获取图片
    avatariv.setImageBitmap(image)// 显示出来
}
suspend fun suspendingGetImage(id: String) = withContext(Dispatchers.IO) {
    ...
}

这段履行在主线程的协程，它本质上会往你的主线程post一个Runnable,这个Runnable便是你的协程代码：

handler.post {
    val image = suspendingGetimage(imageId)
    avatarIv.setImageBitmap(image)
}

当这个协程被挂起的时分，便是主线程post的这个Runnable提前完毕，然后持续履行它界面改写的使命。

关于线程，咱们就看完了。
这个时分你或许会有一个疑问，那launch包裹的剩余代码怎样办？

所以接下来，咱们来看看协程这一边。

协程：
线程的代码在抵达suspend函数的时分被掐断，接下来协程会从这个suspend函数持续往下履行，不过是在指定的线程。

谁指定的？是suspend函数指定的，比方咱们这个比方中，函数内部的withContext传入Dispatchers.IO所指定的IO线程。

Dispatchers调度器，它能够将协程约束在一个特定的线程履行，或许将它分派到一个线程池，或许让它不受约束地运转，关于Dispatchers在这儿先不展开了。

那咱们平常里常用的调度器有哪些？
常用的Dispatchers,有以下三种：

• Dispatchers.Main:Androoid中的主线程
• Dispatchers.IO:针对磁盘和网络IO进行了优化，合适IO密集型的使命，比方：读写文件，操作数据库以及网络恳求。
• Dispatchers.Default:合适CPU密集型的使命，比方核算

回到咱们的协程，它从suspend函数开端脱离发动它的线程，持续履行在Dispatchers所指定的IO线程。

紧接着在suspend函数履行完结之后，协程为咱们做的最爽的作业就来了：会主动帮咱们把线程再切回来。

这个「切回来」是什么意思？

咱们的协程原本是运转在主线程的，当代码遇到suspend函数的时分，产生线程切换，根据Dispatchers切换到了IO线程；

当这个函数履行完毕后，线程又切了回来，「切回来」也便是协程会帮我再post一个Runnable，让我剩余的代码持续回到主线程去履行。

咱们从线程和协程的两个角度剖析完结后，总算能够对协程「挂起」suspend做一个解说：

协程在履行到suspend符号的函数的时分，会被suspend也便是被挂起，而所谓的被挂起，便是切个线程；

不过差异在于，挂起函数在履行完结之后，协程会重新切回它原先的线程。

再简略来讲，再Kotlin中所谓的挂起，便是一个稍后会被主动切回来的线程调度操作。

这个「切回来」的动作，再Kotlin里叫做`resume`康复。

经过方才的剖析咱们知道：挂起之后是需求康复。

而康复这个功用是协程的，假如你不在协程里面调用，康复这个功用没法完成，查找一也就答复了这个问题：为什么挂起函数必须在协程或许另一个挂起函数里被调用。

再细想下这个逻辑：一个挂起函数要么在协程里被调用，要么在另一个挂起函数里被调用，那么它其实直接或许间接地，总是会在一个协程里被调用。

所以，要求suspend函数只能在协程里或许另一个suspend函数里被调用，仍是为了让协程能够在suspend函数切换线程之后再切回来。

怎样就「挂起」了？

咱们了解了什么是「挂起」后，再接着看看这个「挂起」是怎样做到的。

先随意写一个自定义的suspend函数：

suspend fun suspendingPrint() {
    println("Thread: ${Thread.currentThread().name}")
}
I/System.out: Thread:main

输出的成果仍是在主线程。

为什么没切换线程？由于它不知道往哪儿切，需求咱们告诉它。

比照之前的比方中suspendingGetImage函数代码：

suspend fun suspendingGetImage(id: String) = withContext(Dispatchers.IO) {
    ...
}

咱们能够发现不同之处其实在于withContext函数。

其实经过withContext源码能够知道，它本身便是一个挂起函数，它接受一个Dispatcher参数，依靠这个Dispatcher参数的指示，你的协程被挂起，然后切到其他线程。

所以这个suspend，其实并不是起到把任何把协程挂起，或许说切换线程的作用。

真实挂起协程这个事，是Kotlin的协程结构帮咱们做的。

所以咱们想要自己写一个挂起函数，仅仅只加上suspend关键字是不可的，还需求函数内部直接或间接地调用到Kotlin协程结构自带的suspend函数才行。

suspend的意义？

这个suspend关键字，既然它并不是真实完成挂起，那它的左右是什么？

它其实是一个提示。

函数的创立者对函数的运用者的提示：我是一个耗时函数，我被我的创立者用挂起的办法在后台运转，所以请在协程里调用我。

为什么suspend关键字并没有手撕鸡去操作挂起，但Kotlin却把它供给出来？

由于它本来就不是用来操作挂起的。

挂起的操作——也便是切线程，依靠的是挂起函数里面的实际代码，而不是在这个关键字。

所以这个关键字，仅仅一个提示。

还记得方才咱们测验自定义挂起函数的办法吗？

// redundant suspend modifier
suspend fun suspendingPrint() {
    println("Thread: ${Thread.currentThread().name}"})
}

假如你创立一个suspend函数但它内部不包括真实的挂起逻辑，编辑器会与给你一个提示：redundant suspend modifier,告诉你这个suspend是剩余的。

由于你这个函数本质上并没有产生挂起，那你这个suspend关键字只要一个效果：便是约束这个函数只能在协程里被调用，假如在非协程的代码中调用，就会编译不经过。

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

怎样自定义suspend函数？

在了解了suspend关键字的来龙去脉之后，咱们就能够进入下一个话题了：怎样自定义suspend函数。
这个「怎样自定义」其实分为两个问题：

• 什么时分需求自定义suspend函数？
• 详细该怎样写呢？

什么时分需求自定义suspend函数

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

耗时操作一般分为两类：I/O操作和CPU核算作业。比方文件的读写、网络交互、图片的含糊处理，都是耗时的，统统能够把他们写进suspend函数里。

其他这个「耗时」还有一种特殊情况，便是这件事本身做起来并不慢，但它需求等候，比方5秒钟之后再做这个操作。这种也是suspend函数的运用场景。

详细该怎样写

给函数加上suspend关键字，然后再withContext把函数的内容包住就能够了。

说到用withContext是由于它在挂起函数里功用最简略直接：把线程主动切走和切回。

当然并不是只要withContext这一个函数来辅佐咱们完成自定义的suspend函数，比方还有一个挂起函数叫delay，它的作用是等候一段时间后再持续往下履行代码。

运用它就能够所完成方才说到的等候类型的耗时操作：

suspend fun suspendUtilDone() {
    while (!done) {
        delay(5)
    }
}

这些东西，在咱们初步运用协程的时分不必立马接触，能够先把协程最基本的办法和概念理清楚。

总结

咱们今日整个文章其实便是在清理一个概念：什么是挂起？挂起，便是一个稍后会被主动切回来的线程调度操作。

好，关于协程中的「挂起」咱们就解说到这儿。
或许你心中还会存在一些疑问：

• 协程中挂起的「非堵塞式」究竟是怎样回事？
• 协程和RxJava在切换线程方面功用是相同的，都能让你写出防止嵌套回调的复杂并发代码，那协程还有哪些优势，或许让开发者运用协程的理由？

这些疑问的答案，咱们都会鄙人一篇中全部揭晓。

版权声明

本文首发于：# Kotlin 协程的挂起好神奇好难懂？今日我把它的皮给扒了

微信大众号：扔物线