Kotlin Coroutine 一般翻译成协程，顾名思义可以理解成协作程序，它并不是 Kotlin 特有的，很多程序都有协程这个概念。刚开始接触时，对这些概念还是挺费解的。我在这里试图从0开始，讲讲怎么理解协程这个概念，并把它应用到我们的 Android 应用程序开发中来。万事开头难，按照惯例，我也用协程来写一个 Hello World 出来。

1. 添加Android协程依赖库

在 Android 中要使用协程，首先需要引入 Kotlin 的基础库和协程库，kotlin 对协程的支持都在 kotlinx.coroutines包中，在 build.gradle 中添加依赖：

//kotlin基础库和协程库
implementation"org.jetbrains.kotlin:kotlin-stdlib-jdk7:1.3.50"
implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.3.2'

注意，在写这篇文章时，kotlinx-coroutines-android 的版本为1.3.2，同时要求 kotlin 的版本为1.3.50。

为了后面通过网络请求举例来说明协程的作用，同时引入 retrofit 和 rxjava 库：

api 'com.squareup.retrofit2:retrofit:2.6.2'
api 'io.reactivex.rxjava2:rxjava:2.2.13'
api 'io.reactivex.rxjava2:rxandroid:2.1.1'
api 'com.squareup.retrofit2:adapter-rxjava2:2.6.2'
api 'com.squareup.retrofit2:converter-gson:2.6.2'

Android 开发如果不知道 retrofit 和 rxjava 是什么，那么请自行搜索学习了之后再往下阅读。这里需要注意的是，retrofit 早一点的版本，对协程的新特性还不支持。

2. 第一个协程程序

万事俱备只欠东风，随便写一个点击事件，执行以下代码：

println("1.测试开始，创建协程")
GlobalScope.launch {
    println("2.协程开始运行")
    delay(3000)
    println("3.协程内部延迟3s后")
    withContext(Dispatchers.Main) {
        println("4.toast Hello World")
        Toast.makeText(this@MainActivity, "Hello World", Toast.LENGTH_SHORT).show()
    }
}
println("5.协程外部运行")

执行结果如下：

1.测试开始，创建协程
5.协程外部运行
2.协程开始运行
3.协程内部延迟3s后
4.toast Hello World

多次执行，执行结果也可能为：

1.测试开始，创建协程
2.协程开始运行
5.协程外部运行
3.协程内部延迟3s后
4.toast Hello World

执行结果里，"2" 和 "5" 的顺序可能会变化，其他都不变。到这里，可能你会比较懵逼，协程到底是个什么鬼，执行顺序怎么还会变化，先不用管这些，你只需要知道通过 GlobalScope.launch() 方法启动了一个协程就行了。至此，我们已经很直观的感受到了协程。

3. 采用Retrofit来进行一次网络接口请求

首先问一个问题，接口请求成功后，怎么将结果通知出去？目前常见的有2种方式：

1. 通过 callback 回调的方式；
2. 使用 rxjava 类似的框架；

那我们先来写一个例子，采用 retrofit 模拟做一个登录请求：

//接口定义
interface TestService {
    @GET("https://www.baidu.com")
    fun testLogin(): Call<UserInfo>

    @GET("https://www.baidu.com")
    fun testLoginEx(): Flowable<UserInfo>
}

data class UserInfo(val name: String, val age: Int) {
    override fun toString(): String {
        return "UserInfo(name='$name', age=$age)"
    }
}

val testApi: Retrofit by lazy {
    val okHttpClient = OkHttpClient.Builder()
        .addInterceptor { chain ->
            val builder = Response.Builder()
            //为了测试方便，模拟返回数据
            val respBytes = "{"name":"hjy","age":30}".toByteArray()
            val source = Okio.source(ByteArrayInputStream(respBytes))
            //模拟网络请求，线程睡眠3秒钟
            Thread.sleep(3000)
            //随机返回正确结果或者错误结果
            builder.code(if ((Math.random() * 10).toInt() % 2 == 0) 200 else 400)
                .message("")
                .request(chain.request())
                .protocol(Protocol.HTTP_1_1)
                .body(RealResponseBody("application/json", respBytes.size.toLong(), Okio.buffer(source)))
            builder.build()
        }
        .build()
    val retrofitBuilder = Retrofit.Builder()
        .client(okHttpClient)
        .baseUrl("https://wwww.baidu.com")
        .addConverterFactory(GsonConverterFactory.create())
        .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
    retrofitBuilder.build()
}

熟悉 retrofit、okhttp 的，这段代码应该都能看得懂，为了方便测试，我们本地模拟随机返回正确的结果或者返回异常，后面很多实际案例如不做特殊说明，会以此为基础。

如果采用回调的方式来调用接口，常规的写法是：

val call = testApi.create(TestService::class.java).testLogin()
val handler = Handler(Looper.getMainLooper())
call.enqueue(object : retrofit2.Callback<UserInfo> {
    override fun onFailure(call: Call<UserInfo>, t: Throwable) {
        handler.post {
            t.printStackTrace()
        }
    }

    override fun onResponse(call: Call<UserInfo>, response: Response<UserInfo>) {
        handler.post {
            if (response.isSuccessful) {
                println("callback 回调结果：${response.body()}")
            } else {
                println("请求失败：errorCode = ${response.code()}")
            }
        }
    }
})

如果采用 rxjava 的方式来调用接口，常规的写法是：

testApi.create(TestService::class.java)
    .testLoginEx().subscribeOn(Schedulers.io())
    .observeOn(AndroidSchedulers.mainThread())
    .subscribe({ userinfo ->
        println("调用成功：${userinfo}")
    }, { exception ->
        println(exception.message)
    })

上面这样的代码，相信每个人都写过成百上千遍了，那么我根据经验来评价下这2种方式：

1. 回调的方式处理接口请求已是上古时代的产物了，在 Android 中更新 UI 必须在主线程中执行，所以最终相当于嵌套了 2 个 callback，一不小心就会产生回调地狱；
2. rxjava 相比回调的方式已经优雅很多了，在没有使用协程之前，可以认为是目前的最优方案。但是如果你用过 map、flatMap 等操作符，一些眼花缭乱的操作，虽然功能很强大，但对开发者来说真的是，如果能不用就不用吧；
3. 如果有多个异步请求需要串行执行或者并行请求，这2种方式写起来都很蛋疼；

4. 使用协程来请求接口

先定义接口，需要注意的是 retrofit 2.6.0 开始才能直接支持协程，老版本是不直接支持的，需要其他方式来实现，我这里略过不介绍了：

@GET("https://www.baidu.com")
suspend fun testLoginByCoroutine(): UserInfo

与 rxjava 的接口相比，增加了 suspend 关键字，返回结果直接是返回的对象，去掉了 Flowable 的包装，再看如何调用：

MainScope().launch {
    try {
        val userInfo = testApi.create(TestService::class.java).testLoginByCoroutine()
        //以下结果会在主线程执行
        println("调用成功：$userInfo")
    } catch (e: Exception) {
        //结果会在主线程执行
        println(e.message)
    }
}

这里通过 MainScope().launch(...) 启动了一个协程，MainScope() 是类似 GlobalScope 的东西，只不过它默认是在主线程执行，现在可以先不用理会它。令人惊讶的是，协程体内的代码居然都是顺序执行，完全没有了回调，并且以上代码并不会阻塞主线程，且返回的结果也是在主线程，现在居然线程切换的代码都不用了。

以同步的方式来写异步的代码，代码简单，逻辑清晰明了，有了它我再也不想用 rxjava 了。熟悉 javascript 的同学肯定了解，这不是与 js 里的 async、await 有异曲同工之妙么。

5. 使用协程来请求多个接口

如果上面这个例子，你看不出协程有多大优势的话，那么我们来看个更复杂的例子。假设我们有这样一个业务场景：第一步需要先调用登录接口，如果登录成功则需要从服务端获取某些信息，然后才能进行后面的操作。也就是说需要先后调用2个接口，并且前一个接口的结果会影响后面的流程。同样我们使用协程来模拟这种情况：

MainScope().launch {
    try {
        val testService = testApi.create(TestService::class.java)
        //第一次调用
        val userInfo1 = testService.testLoginByCoroutine()
        println("第一个接口调用成功：$userInfo1")
        //前面接口调用成功后，调用另一个接口 
        val userInfo2 = testService.testLoginByCoroutine()
        println("第二个接口调用成功：$userInfo2")
    } catch (e: Exception) {
        println("出现异常：${e.message}")
    }
}

出现的结果可能会有：

第一个接口调用成功：UserInfo(name='hjy', age=30)
第二个接口调用成功：UserInfo(name='hjy', age=30)

或者

出现异常：HTTP 400

或者

第一个接口调用成功：UserInfo(name='hjy', age=30)
出现异常：HTTP 400

至少到这里，我可以说使用协程有这些好处：

1. 帮助你告别回调地狱；
2. 优雅的线程切换，甚至让你无感知；
3. 统一异常处理入口，降低异常处理的复杂度；

6. 协程到底是什么？

前面这些例子，如果你亲手敲一遍代码，并执行看看结果，那么你对协程就会有很直观的感受了。那么协程到底是什么呢？

一个操作系统可管理多个进程，一个进程可管理多个线程。平时我们写 Java 时，所谓的异步任务都是运行在线程当中的。而线程的切换，最典型的是 Android 中，我们在 IO 线程请求接口，接口返回成功后需要切换到主线程更新 UI。这种一个进程中线程的切换，都是由操作系统来调度的，程序并不好控制。

协程是一种比线程更轻量级的存在，网上很多人说协程是轻量级的线程，我觉得这种说法不靠谱，很容易误导人。协程并不是线程，它就是一种特殊的函数：它可以在某个地方挂起，并且可以在以后的某个时间点，重新在挂起处继续运行。协程的执行最终靠的还是线程，应用程序来调度协程选取合适的线程来获取执行权。把应用程序比作操作系统，协程就像线程一样，应用程序可以自己来操作和调度协程的运行。