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种方式：
- 通过 callback 回调的方式；
- 使用 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种方式：
- 回调的方式处理接口请求已是上古时代的产物了，在 Android 中更新 UI 必须在主线程中执行，所以最终相当于嵌套了 2 个 callback，一不小心就会产生回调地狱；
- rxjava 相比回调的方式已经优雅很多了，在没有使用协程之前，可以认为是目前的最优方案。但是如果你用过 map、flatMap 等操作符，一些眼花缭乱的操作，虽然功能很强大，但对开发者来说真的是，如果能不用就不用吧；
- 如果有多个异步请求需要串行执行或者并行请求，这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
至少到这里，我可以说使用协程有这些好处：
- 帮助你告别回调地狱；
- 优雅的线程切换，甚至让你无感知；
- 统一异常处理入口，降低异常处理的复杂度；
6. 协程到底是什么？
前面这些例子，如果你亲手敲一遍代码，并执行看看结果，那么你对协程就会有很直观的感受了。那么协程到底是什么呢？
一个操作系统可管理多个进程，一个进程可管理多个线程。平时我们写 Java 时，所谓的异步任务都是运行在线程当中的。而线程的切换，最典型的是 Android 中，我们在 IO 线程请求接口，接口返回成功后需要切换到主线程更新 UI。这种一个进程中线程的切换，都是由操作系统来调度的，程序并不好控制。
协程是一种比线程更轻量级的存在，网上很多人说协程是轻量级的线程，我觉得这种说法不靠谱，很容易误导人。协程并不是线程，它就是一种特殊的函数：它可以在某个地方挂起，并且可以在以后的某个时间点，重新在挂起处继续运行。协程的执行最终靠的还是线程，应用程序来调度协程选取合适的线程来获取执行权。把应用程序比作操作系统，协程就像线程一样，应用程序可以自己来操作和调度协程的运行。
