总结：协程就是 Kotlin 提供的一套线程封装的 API

Java中的并发操作例子：

new Thread(new Runnable() {
    
    @Override
    public void run() {
    
        //耗时任务
    }
}).start();

kotlin中线程的例子：

Thread {
    
    //耗时任务
}.start()

同java一样，不知道线程何时结束和执行结果

高级一点，在java中可以使用线程池Executor来管理线程，例根据需要创建新线程的线程池

ExecutorService es = Executors.newCachedThreadPool();
es.submit(new Runnable() {
    
    @Override
    public void run() {
    
        //耗时任务
    }
});

同样可以在kotlin中使用

val es: ExecutorService = Executors.newCachedThreadPool()
es.execute({
    
    //耗时任务
})

在kotlin中也可以使用Android的AsyncTask来处理线程间的通信

object : AsyncTask<T0, T1, T2> {
    
    override fun doInBackground(vararg args: T0): String {
     ... }
    override fun onProgressUpdate(vararg args: T1) {
     ... }
    override fun onPostExecute(t3: T3) {
     ... }
}

可以看到，使用Android的方法，强制的把线程切换设成了前台，后台，更新三个步骤，多层嵌套就更麻烦了。
可以使用RxJava和kotlin 的协程来简化逻辑和代码，比如使用协程

launch({
    val user = api.getUser() //  网络请求（IO 线程）
    nameTv.text = user.name  //  更新 UI（主线程）
})

协程的好处

闭包原则

创建线程

//正常写法
Thread(object : Runnable {
    
    override fun run() {
    
    	//耗时任务
    }
})
//定义了SAM的接口，使得以其为参数的方法，可以在调用时，使用一个lambda表达式作为参数
//可以简化为
Thread({
    
    //耗时任务
})
//使用闭包，简化为
Thread {
    
    //耗时任务
}

在 Kotlin 中有这样一个语法糖：当函数的最后一个参数是 lambda 表达式时，可以将 lambda 写在括号外。这就是它的闭包原则。

launch 函数，可以通过闭包来进行简化

创建线程的方式

// 方法一，使用 runBlocking 顶层函数
runBlocking {
    
    // do sth
}
​
// 方法二，使用 GlobalScope 单例对象
//            可以直接调用 launch 开启协程
GlobalScope.launch {
    
    // do sth
}
​
// 方法三，自行通过 CoroutineContext 创建一个 CoroutineScope 对象
//  需要一个类型为 CoroutineContext 的参数 比如Dispatchers.Main 和 Dispatchers.IO
val coroutineScope = CoroutineScope(context)
coroutineScope.launch {
    
    // do sth
}

三种方式的优缺点

方法一通常适用于单元测试的场景，而业务开发中不会用到这种方法，因为它是线程阻塞的。
方法二和使用 runBlocking 的区别在于不会阻塞线程。但在 Android 开发中同样不推荐这种用法，因为它的生命周期会和 app 一致，
且不能取消。
方法三是比较推荐的使用方法，我们可以通过 context 参数去管理和控制协程的生命周期（这里的 context 和 Android 里的不是
一个东西，是一个更通用的概念，会有一个 Android 平台的封装来配合使用）。

常用方法

协程最常用的功能是并发，多用在线程切换，例

coroutineScope.launch(Dispatchers.Main) {
           // 开始协程：主线程
    val token = api.getToken()                  // 网络请求：IO 线程
    val user = api.getUser(token)               // 网络请求：IO 线程
    nameTv.text = user.name                     // 更新 UI：主线程
}

如果是多个网络请求，根据两个请求的结果来主线程展示

coroutineScope.launch(Dispatchers.Main) {
    
    val avatar = async {
     api.getAvatar(user) }    // 获取用户头像
    val logo = async {
     api.getCompanyLogo(user) } // 获取用户所在公司的 logo
    val merged = suspendingMerge(avatar, logo)    // 合并结果  调用非阻塞式挂起的函数 使用 suspend修饰
    show(merged) // 更新 UI
}

协程切换线程过程可使用withContext函数，执行后自动切换回原有线程

coroutineScope.launch(Dispachers.Main) {
     //主线程
    ...
    withContext(Dispachers.IO) {
     //切到子线程执行，执行完切回主线程
        ...
    }
    ... //主线程
    withContext(Dispachers.IO) {
     //切到子线程执行，执行完切回主线程
        ...
    }
    ... //主线程
}

suspend关键字，非阻塞式挂起