（转载）Kotlin的协程Coroutine详解

前言

Kotlin协程是什么，如何使用？如何结合Retrofit使用？

Kotlin协程的优势在哪里？相信看完这一篇你一定有所收获！

先说说我认为的协程

其实很简单，就是一个线程调度工具或者线程管理工具

或者更直白点，就可以理解为一个线程框架

对应java里面，就是一个线程池的概念

只不过协程是一个封装好了、便于使用和来回切换线程的线程池

所以我才说是一个线程调度工具或者线程框架

协程基本使用

若使用协程，首先我们得引入协程相关的开发包

implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.3.7-mpp-dev-11'
implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.3.7-mpp-dev-11'

上面一个是java环境的，下面一个是android环境下的，这里我们都引入进来。

协程最简单的使用，我们可以使用GlobalScope.launch去开启一个协程代码如下所示：

GlobalScope.launch {
    Log.d(TAG, Thread.currentThread().name)
}

运行结果如下所示：

说明这段代码是运行在一个子线程中的，

当然我们可以再launch中传递参数，让他运行在主线程中：

GlobalScope.launch(Dispatchers.Main) {
    Log.d(TAG, Thread.currentThread().name)
}
 

这样里面的这段代码就运行在主线程中了，

由此可见 协程是什么？

简单的说就是协程可以让我们开启一个线程，是一个线程框架。

当然实际项目中，开启协程我们不会使用上面的方法。别急，我们要循序渐进~

协程和线程相比，有什么优势

协程和线程相比的优势，我们直接用一个例子来说明，

比如当前我们要去请求网络，拿到数据后将数据显示出来，

这里我们模拟两个方法，

分别为 网络请求获取数据 和 将数据显示在UI上，

我们定义方法如下:

/**
 * 从服务器取信息
 */
private fun getMessageFromNetwork(): String {
 
    for (i in 0..1000000) {
        //这里模拟一个耗时操作
    }
 
    var name = "Huanglinqing"
    return name
}
 
/**
 * 显示信息
 * @message :信息
 */
private fun showMessage(message: String) {
    tvName.text = message
}

由于getMessage是一个耗时操作，

所以我们将他放在子线程中，

而在Android中 UI更新操作不能放在子线程中，

所以我们必须将showMessage方法放在UI线程中，

在之前我们实现这种需求 只能自己去执行切线程的代码，代码如下所示

/**
 * 从服务器取信息
 */
private fun getMessageFromNetwork() {
 
    for (i in 0..1000000) {
        //这里模拟一个耗时操作
    }
 
    var name = "Huanglinqing"
    runOnUiThread {
        showMessage(name)
    }
}

在onCreate中执行如下代码：

Thread {
    getMessageFromNetwork()
}.start()

这样呢 看起来还好，但是如果现在需求改为：

请求第一个 后 显示出来，再请求第二个 显示出来呢，

代码就是这个样子

private fun getMessageFromNetwork() {
 
    for (i in 0..1000000) {
        //这里模拟一个耗时操作
    }
 
    var name = "Huanglinqing"
    runOnUiThread {
        showMessage(name)
        Thread{
            getMessageFromNetwork1()
            runOnUiThread{
                
            }
        }.start()
    }
}

依次类推，我们可以想到，如果请求很多的话，

第一 代码结构会很难看，

第二 写着写着就很乱了，

那么协程就可以很好的解决这个问题，下面我们来看使用协程的方式 怎么写.

首先，对于一个耗时的操作，我们需要将他切换到后台线程执行，

withContext函数可以构建一个协程作用域，

他必须在挂起函数或者协程中执行，

suspend关键字是kotlin为我们提供的 用于标记挂起函数的关键字。

我们修改getMessageFromNetwork方法如下:

/**
 * 从服务器取信息
 */
private suspend fun getMessageFromNetwork(): String {
 
    var name = ""
    withContext(Dispatchers.IO) {
        for (i in 0..1000000) {
            //这里模拟一个耗时操作
        }
 
        name = "Huanglinqing1111"
    }
 
    return name
}

在onCreate中协程中直接这样写：

GlobalScope.launch(Dispatchers.Main) {
    var name = getMessageFromNetwork()
    showMessage(name)
}

运行结果如下所示：

如果我们有多个请求呢，那就再多加几个

GlobalScope.launch(Dispatchers.Main) {
    var name = getMessageFromNetwork()
    showMessage(name)
    var name1 = getMessageFromNetwork()
    showMessage(name1)
    var name2 = getMessageFromNetwork()
    showMessage(name2)
}

这样getMessageFromNetwork在后台执行，showMessage在前台执行，由此看来。

协程比线程的优势在什么地方？

1、协程可以帮我们自动切线程

2、摆脱了链式回调的问题

协程的挂起与恢复

在协程里，协程有挂起和恢复两个状态

其实理解起来也很简单

需要注意的是，挂起和阻塞是有区别的

阻塞是指单个线程的状态

而挂起是针对协程才有的状态

其实挂起就是协程执行了切换线程的操作

恢复自然就是从另外一个线程切换回来

回到原来的协程了

拿上面演示的这段代码来看：

GlobalScope.launch(Dispatchers.Main) {
    var name = getMessageFromNetwork()
    showMessage(name)
}

当执行getMessageFromNetwork方法时

这时候协程切换到了另外一个子线程

下面的showMessage不会立马执行

这时候就说协程被挂起了

等到getMessageFromNetwork执行完成后

然后回到协程继续执行下面的showMessage方法

我们就说协程被恢复了

当然，协程的挂起不只是withContext(Dispatchers.IO)才能实现

比如delay(1000)这个方法

也可以实现挂起

只不过这个方法的意思是协程挂起一秒

一般用来处理延时操作

更多的方法大家可以去了解

或者自己根据实际业务写自己的挂起方法

Retrofit 如何使用协程

从Retrofit2.6.0开始，retrofit就自动支持协程了，

这里我们从「聚合数据」上找到一个开放api

我们先来看之前我们怎么使用的，首先在Apiservice中定义一个接口如下：

@GET("https://wanandroid.com/article/listproject/0/json")
fun queryData(): Call<BaseReqData<DataReqBean>>

在activity中添加如下代码：

var retrofit = Retrofit.Builder()
    .baseUrl("http://v.juhe.cn/")
    .addConverterFactory(GsonConverterFactory.create())
    .build()
 
val apiService = retrofit.create(ApiService::class.java)
 
tvName.setOnClickListener {
    apiService.queryData("top","04ea095cbea56775e2d1669713f34cc2")
        .enqueue(object :Callback<BaseReqData<NewBean>>{
            override fun onFailure(call: Call<BaseReqData<NewBean>>, t: Throwable) {
                tvName.text = t.toString()
                Log.d("网络请求错误", t.toString())
            }
 
            override fun onResponse(
                call: Call<BaseReqData<NewBean>>,
                response: Response<BaseReqData<NewBean>>
            ) {
                tvName.text = response.code().toString()
            }
        })
}

这里我们将返回结果的状态码显示在view上，运行结果如图所示：

上面代码看起来没有什么问题，

如果我们用到了mvp模式什么的，便于职责单一，还要单独放一个类中，

这样就需要添加回调才能获取返回结果。

那么协程中怎么使用呢?

首先我们在ApiService中新增一个函数 ，声明为挂起函数，类型不需要添加Call

@GET("toutiao/index")
suspend fun queryDataKotlin(@Query("type") type: String?, @Query("key") key: String?): BaseReqData<NewBean>

在onCreate中代码如下所示：

GlobalScope.launch(Dispatchers.Main) {
    try {
        var result = apiService.queryDataKotlin("top", "04ea095cbea56775e2d1669713f34cc2")
        tvName.text = result.toString()
    }catch (e:Exception){
        tvName.text = e.toString()
    }
}

没错就是这么简单，没有什么回调，

因为queryDataKotlin是一个挂起函数，

当运行到挂起函数的时候，协程会处于等待状态，

等返回结果后，主动切回主线程，执行下面的方法。

而try catch的作用，就等同于上面onFailure的回调，

这个时候你可能会说了，我去！还要写try catch ，好low的感觉，

别忘了，协程的另一个优势就是可以减少回调，

如果仍然有成功方法或者失败方法 那还是走了回调的逻辑！

协程的“假并行”

协程可以提升什么效率，

假设，我们现在有两个接口请求，

需要等到两个接口都请求完毕的时候 显示出结果，

如果在之前会怎么样，先请求接口1 接口1有结果后再请求结果2，

而协程可以做到，接口1和接口2同时请求，

等请求结束后将结果合并显示过来，

也就是以同步的方式去执行异步代码

这里我们请求统一接口来模拟请求两个不同的接口

                //两个接口并行请求
                mainscope.launch(Dispatchers.Main) {
                    var getBodyEntity: GetBodyEntity = GetBodyEntity()
                    var postBodyEntity: PostBodyEntity = PostBodyEntity()
                    try {
                        val customerInfo = async { INetClient.getApiService().customerInfo() }
                        getBodyEntity = customerInfo.await() as GetBodyEntity
                    } catch (e: Exception) {
                        //第一个接口出错的信息
                    }
                    try {
                        val postTemperature = async {
                            var map: MutableMap<String?, String?> = mutableMapOf()
                            map["weaid"] = "1"
                            map["date"] = "2018-08-13"
                            map["appkey"] = "10003"
                            map["sign"] = "b59bc3ef6191eb9f747dd4e83c99f2a4"
                            map["format"] = "json"
                            INetClient.getApiService().postTemperature(map)
                        }
                        postBodyEntity = postTemperature.await() as PostBodyEntity
                    } catch (e: Exception) {
                        //第二个接口出错的信息
                    }
                    strtv.text = "getBodyEntity:${getBodyEntity?.data?.customer_service?.phone}\npostBodyEntity:${postBodyEntity.result[5].citynm}"
                }
            

这样，本来要分步做的两件事情可以同时做了，

当然可以提高效率了，

async函数必须在协程作用域中调用，会创建一个新的子协程，

并返回一个Deferred对象，调用这个对象的await方法 就可以获取执行结果。

但其实，需要注意一点

这个并行完成，其实是假的并行完成

提升的所谓效率

也只是代码量的嵌套优化而已

并不会提升真正的接口请求速度

为什么这么说？

因为协程其实内部还是串行去调用这两个接口的

并不是同时执行完了最后去获取执行结果

这个需要注意“同时”这个字眼

因为我们前面说了

协程是用同步的方式去执行异步操作

所以看起来是在同时执行两个接口请求

但其实只是代码优化后的样子

并不会真实的提升调用两个接口的效率

所以我才说是“假并行”

举个例子：

假设接口A耗时3S，接口B耗时5S

如果是串行执行两个接口

那么最后获取执行结果需要3+5=8S

如果是真的并行两个接口

那么最后获取执行结果的时间就是最慢的接口返回数据的时间，

也就是5S

协程以看起来是同时执行的方式去调用两个接口

最终还是要花8S

优化的只是代码风格

所以说是“假并行”

在线上项目中如何使用协程

创建协程的方法有很多，有我们上面说的GlobalScope.launch方法，

还有runBlocking方法

GlobalScope.launch 创建的是顶级协程，

它的生命周期是process级别的

即使Activity被销毁，协程仍在执行

这就会导致任务泄漏

不利于回收

runBlocking创建的协程在协程作用域的代码没有执行完毕前会一直阻塞线程，

所以上面。两个方法都不建议使用。

coroutineScope函数是一个挂起函数，

它会继承外部的协程作用域并创建一个子协程,只能在协程作用域或者挂起函数中调用

launch函数必须在协程的作用域中才能调用。

说了这么多 在项目中我们改如何创建协程呢？

我们可以直接创建一个CoroutineScope对象，如下所示：

var coroutineScope = CoroutineScope(Dispatchers.Main)

coroutineScope.launch {
 
}

这样我们就创建了一个协程，可以按照上面的方法使用了

如果在页面打开的时候，我们在协程中进行网络请求，当页面销毁的时候我们也要将协程任务取消以免造成不必要的问题

如何取消协程任务

coroutineScope 直接调用cancle方法即可，

如果我们使用的是GlobalScope.launch方法 ，

它会返回一个job对象 我们使用job.cancle即可取消协程任务。

最后的最后，除了GlobalScope

还有这几个自带的CoroutineScope可以给我们使用

MainScope:

在Activity中使用，可以在Ondestroy方法中取消协程

viewModelScope：

只能在Viewmodel中使用，绑定Viewmodel的生命周期

lifecycleScope：

只能在Activity，Fragment中使用，绑定Activity，Fragment的生命周期

关于协程的内容，就讲到这里了

其他更多方便快捷的使用方式，就要大家多去探索了

写了个demo，下载链接如下：

链接：https://pan.baidu.com/s/125XJYpeIVuOyYOU6vVu-3A
提取码：

pzoy