3.协程-挂起函数

本文主要是介绍3.协程-挂起函数，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

上一篇，我们知道了非阻塞挂起的核心是要执行一个挂起函数，挂起函数的作用就是启动线程执行耗时任务，耗时任务执行完毕，通知调用线程继续执行后续的代码。那么我们如何定义挂起函数呢？有哪些方式呢？接下来我们揭开它的面纱

一、定义挂起函数

挂起函数是协程的一个分水岭， 挂起函数前后的代码都是在调用线程执行的（当然我们可以通过调度器来改变这种状态，这个后续讲），挂起函数就是分割这2部分代码的关键。

// 1.启动一个协程
GlobalScope.launch {/*** 挂起函数前的代码*/println("1:${Thread.currentThread().name}")/*** 执行挂起函数(分水岭)*/delay(1000)/*** 挂起函数后的代码*/println("2:${Thread.currentThread().name}")
}

我们知道 delay 就是自带的一个可以做延迟的挂起函数，它是如何定义的呢？

public suspend fun delay(timeMillis: Long) {if (timeMillis <= 0) return // don't delayreturn suspendCancellableCoroutine sc@ { cont: CancellableContinuation<Unit> ->cont.context.delay.scheduleResumeAfterDelay(timeMillis, cont)}
}

定义挂起函数的关键需要通过一个 suspend 关键词修饰函数。那么 suspend 修饰的函数是如何在做到切换线程执行耗时任务，并通知调用线程执行完毕呢？

这里提醒大家 suspend 关键词，在 Kotlin 中起到的是一个提示的作用，提示此函数是一个挂起函数，它要在协程中运行，并且内部方法要调用其他的 suspend 函数，大家先记住我这句话，因为相对于生成的 Java 字节码 suspend 存在另外的功能，现在读不懂这句话也无所谓我们继续看后面的代码。

接下来我们定义一个属于自己的延迟的挂起函数。

fun main() {GlobalScope.launch {myDelay(2000)println("延迟消息执行!")}Thread.currentThread().join()
}/*** 自定义延迟消息*/
suspend fun myDelay(timeMillis: Long) = suspendCoroutine<Unit> { continuation ->/*** 启动新的线程做延迟*/thread {/*** 线程执行延迟消息*/Thread.sleep(timeMillis)/*** 通知调用线程执行完毕,你可以继续了*/continuation.resume(Unit)}
}

看到了吗？我们创建的挂起函数是重新创建了一个线程执行延迟，然后通过一个 continuation 对象的 resume 方法，通知调用线程我执行完毕了（有没有感觉类似像写回调函数）。

看上面的 continuation 对象，有没有像回调函数啊？其实本身就是回调函数，不信你编译成 Java 代码去瞧一瞧，你就知道协程的原理了和我第一篇协程说过一样，编译器欺骗了你的眼睛，后续原理篇我带大家仔细看或者你尝试用 Java 去调用挂起函数。

continuation 可以通过 resume 可以传递一个结果，这个结果就是挂起函数的返回值。如果你不调用 continuation 的 resume 方法，那么挂起函数后的代码永远不会执行。

不信你就试一试。若我们要没有调用 continuation 的 resume 方法，虽然后面的代码没有被执行，但是调用线程没有被阻塞的哦，只有挂起函数内启动线程是处于阻塞状态。

二、实战

这篇章我们只讲解实战去定义挂起函数。大伙可以模仿，其实 Kotlin 为我们定义了很多 suspend 函数，方便我们去使用。
例如：当 Activity 启动后，我们就执行一个耗时操作加载数据，数据加载完毕后，用数据渲染界面。

class MainActivity : AppCompatActivity(), CoroutineScope by MainScope() {override fun onCreate(savedInstanceState: Bundle?) {.../*** 启动协程*/GlobalScope.launch(Dispatchers.Main) {/*** 展示正在加载中*/showLoadDialog()/*** 执行挂起函数，执行耗时任务*/val reslut = loadData("1")/*** 填充界面*/initView(reslut)/*** dismiss Dialog*/dismissDialog()}...}suspend fun loadData(parameter: String): List<String> {return withContext(Dispatchers.IO) {// 在线程中加载数据,我这里就模拟数据了val reslut = netRqeust(parameter)// 返回数据reslut.split("\n")}}
}

这时候有小伙伴问 withContext 是什么啊？其实 withContext 也是一个挂起函数，还记得我前面说过吗？挂起函数的作用就是执行一个其他的挂起函数。

当然我们也可以通过 suspendCoroutine 挂起函数，来定义我们的挂起函数。但是这种的形式我们还需要在自己去手动创建一个线程。

Kotlin 中为我们提供了一个 withContext 的挂起函数，它可以负责帮我们创建一个线程，并且帮我们调用 continuation 对象的 resume 方法，对应 resume 的参数就是传入的 lambda 表达式的返回值。

Dispatchers.IO 是一个线程调度器，意思是 withContext 的 lambda 表达式，要在新的线程中执行，这个后续会详细讲解。

当然如果我们不想多抽取一个 loadData 的挂起函数也是可以的，我们可以直接执行 withContext 挂起函数。

class MainActivity : AppCompatActivity(), CoroutineScope by MainScope() {override fun onCreate(savedInstanceState: Bundle?) {.../*** 启动协程*/GlobalScope.launch(Dispatchers.Main) {/*** 展示正在加载中*/showLoadDialog()// 这里：我们直接执行 withContext 挂起函数val reslut = withContext(Dispatchers.IO){// 在线程中加载数据,我这里就模拟数据了val reslut = netRqeust()// 返回数据reslut.split("\n")}/*** 填充界面*/initView(reslut)/*** dismiss Dialog*/dismissDialog()}...}
}

三、补充

这篇我们学会了如何去定义一个挂起函数，我们可以通过 withContext 来做创建线程和通知的功能，也可以通过 suspendCoroutine 挂起函数，手动处理返回结果。那我们用的时候如何选择呢？
其实很简单，如果以前存在一个方法，已经有异步请求的封装，但是你还想用协程封装下，想用协程的同步写法，那我们就应该使用 suspendCoroutine 挂起函数的形式去定义，其他的用 withContext 即可。
举个例子:
例如我们用别人的 SDK ，有一个方法是耗时的，对方已经为我们暴露了一个方法，我们只需要调用并传入 CallBack 回调即可。
此时我想将其封装成一个挂起函数要如何做呢？

fun main() {/*** sdk 为我们提供的耗时方法* 它内部肯定已经启动了线程做耗时操作*/PushManager.initPush(object :PushManager.PushCallBack{override fun onSucceed() {}override fun onError() {}})
}

若我们想封装上面的方法，便可以使用调用 suspendCoroutine 挂起函数来实现。

fun main() {GlobalScope.launch {/*** 用同步的代码,写异步的功能* 协程的核心作用*/val reslut = initPush()if (reslut=="成功"){// 执行成功的代码}}
}suspend fun initPush()=suspendCoroutine<String>{PushManager.initPush(object :PushManager.PushCallBack{override fun onSucceed() {/*** 通知成功*/it.resume("成功")}override fun onError() {/*** 通知失败*/it.resumeWithException(RuntimeException("出错"))}})
}

最后大家应该就能理清楚了吧。其实在 2.7.0 以上 Retrofit 高版本的，已经支持协程了，我们定义的请求网络接口函数，可以直接通过 suspend 修饰。
这会大家就应该思考下 Retrofit 的定义的协程的 CallAdapter 是如何通过代理去实现的挂起函数。其实就是通过调用了 suspendCoroutine 挂起函数，因为 OkHttp 内部提供异步请求的方案。

请看 retrofit2 包下的 KotlinExtensions 里，为 Call 定义的一个 await 扩展函数。

suspend fun <T : Any> Call<T>.await(): T {// 调用 suspendCancellableCoroutine 挂起函数return suspendCancellableCoroutine { continuation ->continuation.invokeOnCancellation {cancel()}// 注意这里，使用的就是 OkHttp enqueue 方法，执行异步请求网络enqueue(object : Callback<T> {override fun onResponse(call: Call<T>, response: Response<T>) {if (response.isSuccessful) {val body = response.body()if (body == null) {val invocation = call.request().tag(Invocation::class.java)!!val method = invocation.method()val e = KotlinNullPointerException("Response from " +method.declaringClass.name +'.' +method.name +" was null but response body type was declared as non-null")// 通知执行出错continuation.resumeWithException(e)} else {// 通知执行完成，并 resume 数据。continuation.resume(body)}} else {// 通知出错continuation.resumeWithException(HttpException(response))}}override fun onFailure(call: Call<T>, t: Throwable) {// 通知出错continuation.resumeWithException(t)}})}
}

所以说当我们调用 retrofit 生成的 suspend 请求函数的时候，已经不需要在调用一次 withContext 切换线程了，这是很多人的一个误区。

interface OneDayMsgApi {@GET("/dsapi")suspend fun getOneDayMsg(): OneDayMsgBean
}

GlobalScope.launch(Dispatchers.Main) {showDialog()/*** 很多人喜欢在用一次 withContext 切换线程* 其实这样做是多此一举的*/val oneDayMsg = withContext(Dispatchers.IO){OneDayMsgRetrofit.api.getOneDayMsg()}dissMissDialog()
}

最合适的写法是不需要写 withContext 的。

GlobalScope.launch(Dispatchers.Main) {showDialog()/*** 直接调用即可了 Retrofit 已经为我们定义了挂起函数了* 已经帮我们创建另外一个线程去执行了*/val oneDayMsg = OneDayMsgRetrofit.api.getOneDayMsg()dissMissDialog()
}

这篇关于3.协程-挂起函数的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！

---