Kotlin:玩转协程

协程是什么——它就是个线程框架。

协程是 Kotlin 提供的一套线程封装的 API。
优点：不用关注多线程，就能够让复杂的并发代码，写起来变得简单且清晰。
相似内容：

• 像 Java 中的 Executor线程池来进行线程管理；
• 像Android 中的 AsyncTask 来解决线程间通信；
• 相比RxJava 可以更简洁地消除回调式写法。

基本使用

准备工作

在Module 下的 build.gradle 引入协程

ext.kotlin_coroutines = '1.3.1'
dependencies {
    ...
    //                                       ? 依赖协程核心库
    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:$kotlin_coroutines"
    //                                       ? 依赖当前平台所对应的平台库
    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:$kotlin_coroutines"
    ...
}

1、创建协程的三种方法：

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

• 方法一（不推荐）通常适用于单元测试的场景，它是线程阻塞的。
• 方法二（不推荐）它不会阻塞线程。但它的生命周期和 app 一致，协程的取消不容易管理。
• 方法三（推荐）我们可以通过 context 参数去管理和控制协程的生命周期。

2、协程的使用

• 串行方式的并发场景。

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

• 并行方式的并发场景，把两个并行请求写成上下两行，最后再把结果进行合并。

coroutineScope.launch(Dispatchers.Main) {
    //            ?  async 异步执行
    val avatar = async { api.getAvatar(user) }    // 获取用户头像
    val logo = async { api.getCompanyLogo(user) } // 获取用户所在公司的 logo
    //                  ?suspendingMerge是我们自定义的一个「挂起」方法
    val merged = suspendingMerge(avatar, logo)    // 合并结果
    show(merged) // 更新 UI
}

• withContext 函数可以切换到指定的线程，并在闭包内的逻辑执行结束之后，会把线程"自动切回来"。

// 写法一
coroutineScope.launch(Dispatchers.Main) {      // ? 在 UI 线程开始
    val image = withContext(Dispatchers.IO) {  // ? 切换到 IO 线程，并在执行完成后切回 UI 线程
        getImage(imageId)                      // ? 将会运行在 IO 线程
    }
    avatarIv.setImageBitmap(image)             // ? 回到 UI 线程更新 UI
} 

// 写法二
launch(Dispachers.Main) {              // ? 在 UI 线程开始
    val image = getImage(imageId)
    avatarIv.setImageBitmap(image)     // ? 执行结束后，自动切换回 UI 线程
}
//                                    ? 可以把 withContext 放进一个单独的函数里面
suspend fun getImage(imageId: Int) = withContext(Dispatchers.IO) {
    ...
}

• suspend关键字「暂停」或者「可挂起」。用来修饰方法只能在协程中调用，这就是“挂起函数”。

3、协程生命周期管理，随Activity销毁而取消。

参考官方：使用协程界面编程指南

• 在基类Activity 实现CoroutineScope by MainScope 协程范围为主线程

abstract class ScopedAppActivity: AppCompatActivity(), CoroutineScope by MainScope() {
    override fun onDestroy() {
        super.onDestroy()
        cancel() // CoroutineScope.cancel 取消协程
    } 
}

• 在界面中调用协程

class MainActivity : ScopedAppActivity() {

    fun asyncShowData() = launch { // Is invoked in UI context with Activity's job as a parent
        // actual implementation
    }
    
    suspend fun showIOData() {
        val deferred = async(Dispatchers.IO) {
            // impl      
        }
        withContext(Dispatchers.Main) {
          val data = deferred.await()
          // Show data in UI
        }
    }
}

• 在其他类中调用协程（例如，使用MVP架构模型）

class ActivityWithPresenters: ScopedAppActivity() {
    fun init() {
        val presenter = Presenter()
        val presenter2 = ScopedPresenter(this)
    }
}

class Presenter {
    suspend fun loadData() = coroutineScope {
        // Nested scope of outer activity
    }
    
    suspend fun loadData(uiScope: CoroutineScope) = uiScope.launch {
      // Invoked in the uiScope
    }
}

class ScopedPresenter(scope: CoroutineScope): CoroutineScope by scope {
    fun loadData() = launch { // Extension on ActivityWithPresenters's scope
    }
}

suspend fun CoroutineScope.launchInIO() = launch(Dispatchers.IO) {
   // Launched in the scope of the caller, but with IO dispatcher
}

参考

• Kotlin 的协程用力瞥一眼
• Kotlin 协程的挂起
• 挂起的「非阻塞式」是怎么回事
• 官方：使用协程界面编程指南