协程

什么是协程？

官方描述：协程通过将复杂性放入库来简化异步编程。程序的逻辑可以在协程中顺序地表达，而底层库会为我们解决其异步性。该库可以将用户代码的相关部分包装为回调、订阅相关事件、在不同线程（甚至不同机器）上调度执行，而代码则保持如同顺序执行一样简单。

协程就像非常轻量级的线程。线程是由系统调度的，线程切换或线程阻塞的开销都比较大。而协程依赖于线程，但是协程挂起时不需要阻塞线程，几乎是无代价的，协程是由开发者控制的。所以协程也像用户态的线程，非常轻量级，一个线程中可以创建任意个协程。

协程很重要的一点就是当它挂起的时候，它不会阻塞其他线程。协程底层库也是异步处理阻塞任务，但是这些复杂的操作被底层库封装起来，协程代码的程序流是顺序的，不再需要一堆的回调函数，就像同步代码一样，也便于理解、调试和开发。它是可控的，线程的执行和结束是由操作系统调度的，而协程可以手动控制它的执行和结束。

使用

首先需要添加依赖：

implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.1.1"

1.runBlocking:T

class MainActivity : AppCompatActivity() {

    val TAG: String = "MainActivityTag"

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        Log.e(TAG, "主线程id：${mainLooper.thread.id}")
        test()
        Log.e(TAG, "协程执行结束")
    }

    private fun test() = runBlocking {
        repeat(8) {
            Log.e(TAG, "协程执行$it 线程id：${Thread.currentThread().id}")
            delay(1000)
        }
    }
}

运行结果

2021-09-09 13:18:32.373 26312-26312/com.wy.myapplication E/MainActivityTag: 主线程id：1
2021-09-09 13:18:32.399 26312-26312/com.wy.myapplication E/MainActivityTag: 协程执行0 线程id：1
2021-09-09 13:18:33.402 26312-26312/com.wy.myapplication E/MainActivityTag: 协程执行1 线程id：1
2021-09-09 13:18:34.403 26312-26312/com.wy.myapplication E/MainActivityTag: 协程执行2 线程id：1
2021-09-09 13:18:35.408 26312-26312/com.wy.myapplication E/MainActivityTag: 协程执行3 线程id：1
2021-09-09 13:18:36.415 26312-26312/com.wy.myapplication E/MainActivityTag: 协程执行4 线程id：1
2021-09-09 13:18:37.418 26312-26312/com.wy.myapplication E/MainActivityTag: 协程执行5 线程id：1
2021-09-09 13:18:38.422 26312-26312/com.wy.myapplication E/MainActivityTag: 协程执行6 线程id：1
2021-09-09 13:18:39.424 26312-26312/com.wy.myapplication E/MainActivityTag: 协程执行7 线程id：1
2021-09-09 13:18:40.427 26312-26312/com.wy.myapplication E/MainActivityTag: 协程执行结束

2.launch:Job

这是最常用的用于启动协程的方式，它最终返回一个Job类型的对象，这个Job类型的对象实际上是一个接口，它包涵了许多我们常用的方法。下面先看一下简单的使用：

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)
    Log.e(TAG, "主线程id：${mainLooper.thread.id}")
    val job = GlobalScope.launch {
        delay(6000)
        Log.e(TAG, "协程执行结束 -- 线程id：${Thread.currentThread().id}")
    }
    Log.e(TAG, "主线程执行结束")
}

//Job中的方法
job.isActive
job.isCancelled
job.isCompleted
job.cancel()
jon.join()

运行结果

2021-09-09 13:23:27.752 26570-26570/com.wy.myapplication E/MainActivityTag: 主线程id：1
2021-09-09 13:23:27.774 26570-26570/com.wy.myapplication E/MainActivityTag: 主线程执行结束
2021-09-09 13:23:33.783 26570-26591/com.wy.myapplication E/MainActivityTag: 协程执行结束 -- 线程id：1395

从执行结果看出，launch不会阻断主线程。

1.协程下上文

上下文可以有很多作用，包括携带参数，拦截协程执行等等，多数情况下我们不需要自己去实现上下文，只需要使用现成的就好。上下文有一个重要的作用就是线程切换，Kotlin协程使用调度器来确定哪些线程用于协程执行，Kotlin提供了调度器给我们使用：

Dispatchers.Main：使用这个调度器在 Android 主线程上运行一个协程。可以用来更新UI 。在UI线程中执行

Dispatchers.IO：这个调度器被优化在主线程之外执行磁盘或网络 I/O。在线程池中执行

Dispatchers.Default：这个调度器经过优化，可以在主线程之外执行 cpu 密集型的工作。例如对列表进行排序和解析 JSON。在线程池中执行。

Dispatchers.Unconfined：在调用的线程直接执行。

2.启动模式

在Kotlin协程当中，启动模式定义在一个枚举类中：

public enum class CoroutineStart {
    DEFAULT,
    LAZY,
    @ExperimentalCoroutinesApi
    ATOMIC,
    @ExperimentalCoroutinesApi
    UNDISPATCHED;
}

一共定义了4种启动模式，下表是含义介绍：

启动模式 作用
DEFAULT 默认的模式，立即执行协程体
LAZY 只有在需要的情况下运行
ATOMIC 立即执行协程体，但在开始运行之前无法取消
UNDISPATCHED 立即在当前线程执行协程体，直到第一个 suspend 调用

3.协程体

协程体是一个用suspend关键字修饰的一个无参，无返回值的函数类型。被suspend修饰的函数称为挂起函数,与之对应的是关键字resume（恢复），注意：挂起函数只能在协程中和其他挂起函数中调用，不能在其他地方使用。

suspend函数会将整个协程挂起，而不仅仅是这个suspend函数，也就是说一个协程中有多个挂起函数时，它们是顺序执行的。看下面的代码示例：

class MainActivity : AppCompatActivity() {

    val TAG: String = "MainActivityTag"

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        GlobalScope.launch {
            val token = getToken()
            val userInfo = getUserInfo(token)
            setUserInfo(userInfo)
        }
        repeat(8){
            Log.e(TAG,"主线程执行$it")
        }
    }
    private fun setUserInfo(userInfo: String) {
        Log.e(TAG, userInfo)
    }

    private suspend fun getToken(): String {
        delay(2000)
        return "token"
    }

    private suspend fun getUserInfo(token: String): String {
        delay(2000)
        return "$token - userInfo"
    }

}

运行结果：

2021-09-09 13:53:05.074 26960-26960/com.wy.myapplication E/MainActivityTag: 主线程执行0
2021-09-09 13:53:05.075 26960-26960/com.wy.myapplication E/MainActivityTag: 主线程执行1
2021-09-09 13:53:05.075 26960-26960/com.wy.myapplication E/MainActivityTag: 主线程执行2
2021-09-09 13:53:05.075 26960-26960/com.wy.myapplication E/MainActivityTag: 主线程执行3
2021-09-09 13:53:05.075 26960-26960/com.wy.myapplication E/MainActivityTag: 主线程执行4
2021-09-09 13:53:05.075 26960-26960/com.wy.myapplication E/MainActivityTag: 主线程执行5
2021-09-09 13:53:05.075 26960-26960/com.wy.myapplication E/MainActivityTag: 主线程执行6
2021-09-09 13:53:05.075 26960-26960/com.wy.myapplication E/MainActivityTag: 主线程执行7
2021-09-09 13:53:09.093 26960-26976/com.wy.myapplication E/MainActivityTag: token - userInfo

4.async

async跟launch的用法基本一样，区别在于：async的返回值是Deferred，将最后一个封装成了该对象。async可以支持并发，此时一般都跟await一起使用，看下面的例子。

class MainActivity : AppCompatActivity() {

    val TAG: String = "MainActivityTag"

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        GlobalScope.launch {
            val result1 = GlobalScope.async {
                getResult1()
            }
            val result2 = GlobalScope.async {
                getResult2()
            }
            val result = result1.await() + result2.await()
            Log.e(TAG,"result = $result")
        }
    }

    private suspend fun getResult1(): Int {
        delay(3000)
        return 1
    }

    private suspend fun getResult2(): Int {
        delay(4000)
        return 2
    }

}

async是不阻塞线程的,也就是说getResult1和getResult2是同时进行的，所以获取到result的时间是4s，而不是7s。

运行结果：

2021-09-09 13:56:37.094 27151-27167/com.wy.myapplication E/MainActivityTag: result = 3