协程 VS 线程，Kotlin技术精讲

协程(coroutines)是一种并发设计模式，您可以在Android 平台上使用它来简化异步执行的代码。协程是在版本 1.3 中添加到 Kotlin 的，它基于来自其他语言的既定概念。

在 Android 上，协程有助于管理长时间运行的任务，如果管理不当，这些任务可能会阻塞主线程并导致应用无响应。使用协程的专业开发者中有超过 50% 的人反映使用协程提高了工作效率。

为什么协程如此重要？

协程是 Kotlin 对比 Java 的最大优势。Java 也在计划着实现自己的协程：Loom，不过这个毕竟还处于相当初级的阶段。而 Kotlin 的协程，可以帮我们极大地简化异步、并发编程、优化软件架构。通过协程，我们不仅可以提高开发效率，还能提高代码的可读性，由此也就可以降低代码出错的概率。

协程基本使用

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

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'
​
1
2
3

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

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

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

运行结果如下所示：

说明这段代码是运行在一个子线程中的，当然我们可以在launch中传递参数，让他运行在主线程中：

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

这样里面的这段代码就运行在主线程中了，由此可见 协程是什么？简单的说就是协程可以让我们开启一个线程，是一个线程框架。当然实际项目中，开启协程我们不会使用上面的方法。别急，我们要循序渐进~

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

协程和线程相比的优势，我们直接用一个例子来说明，比如当前我们要去请求网络，拿到数据后将数据显示出来，这里我们模拟两个方法，分别为 网络请求获取数据 和 将数据显示在UI上，我们定义方法如下:

​
/**
 * 从服务器取信息
 */
private fun getMessageFromNetwork(): String {
​
    for (i in 0..1000000) {
        //这里模拟一个耗时操作
    }
​
    var name = "Huanglinqing"
    return name
}
​
/**
 * 显示信息
 * @message :信息
 */
private fun showMessage(message: String) {
    tvName.text = message
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

由于getMessage是一个耗时操作，所以我们将他放在子线程中，而在Android中 UI更新操作不能放在子线程中，所以我们必须将showMessage方法放在UI线程中，在之前我们实现这种需求 只能自己去执行切线程的代码，代码如下所示

​
/**
 * 从服务器取信息
 */
private fun getMessageFromNetwork() {
​
    for (i in 0..1000000) {
        //这里模拟一个耗时操作
    }
​
    var name = "Huanglinqing"
    runOnUiThread {
        showMessage(name)
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

在onCreate中执行如下代码：

Thread {
    getMessageFromNetwork()
}.start()
1
2
3

这样呢 看起来还好，但是如果现在需求改为：请求第一个 后 显示出来，再请求第二个 显示出来呢，代码就是这个样子

private fun getMessageFromNetwork() {
​
    for (i in 0..1000000) {
        //这里模拟一个耗时操作
    }
    
    var name = "Huanglinqing"
    runOnUiThread {
        showMessage(name)
        Thread{
            getMessageFromNetwork1()
            runOnUiThread{
    
            }
        }.start()
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

依次类推，我们可以想到，如果请求很多的话，第一 代码结构会很难看，第二 写着写着就很乱了，那么协程就可以很好的解决这个问题，下面我们来看使用协程的方式 怎么写。

首先，对于一个耗时的操作，我们需要将他切换到后台线程执行，withContext函数可以构建一个协程作用域，他必须在挂起函数或者协程中执行，suspend关键字是kotlin为我们提供的 用于标记挂起函数的关键字。我们修改getMessageFromNetwork方法如下:

/**
 * 从服务器取信息
 */
private suspend fun getMessageFromNetwork(): String {
​
    var name = ""
    withContext(Dispatchers.IO) {
        for (i in 0..1000000) {
            //这里模拟一个耗时操作
        }
​
        name = "Huanglinqing1111"
    }
​
    return name
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

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

GlobalScope.launch(Dispatchers.Main) {
    var name = getMessageFromNetwork()
    showMessage(name)
}
1
2
3
4

运行结果如下所示：

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

GlobalScope.launch(Dispatchers.Main) {
    var name = getMessageFromNetwork()
    showMessage(name)
    var name1 = getMessageFromNetwork()
    showMessage(name1)
    var name2 = getMessageFromNetwork()
    showMessage(name2)
}
1
2
3
4
5
6
7
8

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

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

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

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

Retrofit 如何使用协程

从Retrofit2.6.0开始，retrofit就自动支持协程了，这里我们从「聚合数据」上找到一个开放api；我们先来看之前我们怎么使用的，首先在Apiservice中定义一个接口如下：

@GET("https://wanandroid.com/article/listproject/0/json")
fun queryData(): Call>
1
2

在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>{
            override fun onFailure(call: Call>, t: Throwable) {
                tvName.text = t.toString()
                Log.d("网络请求错误", t.toString())
            }
​
            override fun onResponse(
                call: Call>,
                response: Response>
            ) {
                tvName.text = response.code().toString()
            }
        })
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

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

上面代码看起来没有什么问题，如果我们用到了mvp模式什么的，便于职责单一，还要单独放一个类中，这样就需要添加回调才能获取返回结果。

那么协程中怎么使用呢?

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

@GET("toutiao/index")
suspend fun queryDataKotlin(@Query("type") type: String?, @Query("key") key: String?): BaseReqData
1
2

在onCreate中代码如下所示：

GlobalScope.launch(Dispatchers.Main) {
    try {
        var result = apiService.queryDataKotlin("top", "04ea095cbea56775e2d1669713f34cc2")
        tvName.text = result.toString()
    }catch (e:Exception){
        tvName.text = e.toString()
    }
}
1
2
3
4
5
6
7
8

没错就是这么简单，没有什么回调，因为queryDataKotlin是一个挂起函数，当运行到挂起函数的时候，协程会处于等待状态，等返回结果后，主动切回主线程，执行下面的方法。

而try catch的作用，就等同于上面onFailure的回调，这个时候你可能会说了，我去！还要写try catch ，好low的感觉，别忘了，协程的另一个优势就是可以减少回调，如果仍然有成功方法或者失败方法 那还是走了回调的逻辑！

协程提升效率

协程可以提升什么效率，假设，我们现在有两个接口请求，需要等到两个接口都请求完毕的时候 显示出结果，如果在之前会怎么样，先请求接口1 接口1有结果后再请求结果2，而协程可以做到，接口1和接口2同时请求，等请求结束后将结果合并显示过来，这里我们请求统一接口来模拟请求两个不同的接口

GlobalScope.launch(Dispatchers.Main) {
    try {
        var result1 =
            async { apiService.queryDataKotlin("top", "04ea095cbea56775e2d1669713f34cc2") }
        var result2 =
            async { apiService.queryDataKotlin("top", "04ea095cbea56775e2d1669713f34cc2") }
        tvName.text = result1.await().toString() + "\n==\n" + result2.await().toString()+"接口2"
    } catch (e: Exception) {
        tvName.text = e.toString()
    }
​
}
1
2
3
4
5
6
7
8
9
10
11
12

运行结果如下所示：

这样，本来要分步做的两件事情可以同时做了，当然可以提高效率了，async函数必须在协程作用域中调用，会创建一个新的子协程，并返回一个Deferred对象，调用这个对象的await方法 就可以获取执行结果。

本文主要解析在Kotlin中的协程简单使用以及和线程的对比优势，有关更多的Kotlin技术，可以参考《Kotlin手册》学习更多核心技术点，可以查看详细类目。

最后

要记住协程的几个 API 很容易，困难的是形成一套完整的协程知识体系。其实，学习协程，相当于一次编程思维的升级。协程思维，它与我们常见的线程思维迥然不同，当我们能够用协程的思维来分析问题以后，线程当中某些棘手的问题在协程面前都会变成小菜一碟。因此，我们相当于多了一种解决问题的手段。