《Kotlin从小白到大牛》第20章：协程

第20章 协程

上一章介绍了线程，本章介绍的协程与线程类似都可以处理并发任务。协程在很多语言中都支持，但Java没有协程支持，Kotlin支持协程编程。本章介绍协程。

20.1 协程介绍

协程(Coroutines)是一种轻量级的线程，协程提供了一种不阻塞线程，但是可以被挂起的计算过程。线程阻塞开销是巨大的，而协程挂起基本上没有开销。
在执行阻塞任务时，会将这种任务放到子线程中执行，执行完成再回调（callback）主线程，更新UI等操作，这就是异步编程。协程底层库也是异步处理阻塞任务，但是这些复杂的操作被底层库封装起来，协程代码的程序流是顺序的，不再需要一堆的回调函数，就像同步代码一样，也便于理解、调试和开发。
线程是抢占式的，线程调度是操作系统级的。而协程是协作式的，而协程调度是用户级的，协程是用户空间线程，与操作系统无关，所以需要用户自己去做调度。

20.2 创建协程

这一节介绍Kotlin中任何编写协程程序。

20.1.1 Kotlin协程API
Kotlin支持协程，通过了丰富的协程编程所需的API，主要是三个方面的支持：
1.语言支持。Kotlin语言本身提供一些对协程的支持，例如Kotlin中的suspend关键字可以声明一个挂起函数。
2．底层API。Kotlin标准库中包含协程编程核心底层API，来自于kotlin.coroutines.experimental包，这些底层API虽然也可以编写协程代码，但是使用起来非常麻烦，笔者不推荐直接使用这些底层API。
3．高级API。高级API使用起来很简单，但Kotlin标准库中没有高级API，它来自于Kotlin的扩展项目kotlinx.coroutines框架（https://github.com/Kotlin/kotlinx.coroutines），使用时需要额外配置项目依赖关系。kotlinx.coroutines包名是kotlinx.coroutines.experimental。

20.2.2 创建支持kotlinx.coroutines项目
由于kotlinx.coroutines提供了高级API，使用起来较标准库中底层API要简单的多。本书重点介绍使用kotlinx.coroutines实现协程编程。kotlinx.coroutines不属于Kotlin标准库，需要额外配置项目依赖关系，因此需要创建IntelliJ IDEA+Gradle项目，项目创建完成后在打开build.gradle文件，添加依赖关系，具体内容如下：
group ‘com.51work6’
version ‘1.0-SNAPSHOT’

apply plugin: ‘java’
apply plugin: ‘kotlin’

sourceCompatibility = 1.8

repositories {
mavenCentral()
}

dependencies {
compile “org.jetbrains.kotlin:kotlin-stdlib-jre8:$kotlin_version”
compile ‘org.jetbrains.kotlinx:kotlinx-coroutines-core:0.19.3’ ①
testCompile group: ‘junit’, name:‘junit’, version: ‘4.12’
}

compileKotlin {
kotlinOptions.jvmTarget =“1.8”
}
compileTestKotlin {
kotlinOptions.jvmTarget =“1.8”
}
group ‘com.51work6’
version ‘1.0-SNAPSHOT’

buildscript {
ext.kotlin_version = ‘1.1.51’ ②

repositories {
    mavenCentral()
}
dependencies {
    classpath"org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
}

}
上述代码第①行compile 'org.jetbrains.kotlinx:kotlinx-coroutines-core:0.19.3’是刚刚添加的依赖关系。另外，还需要检查代码第②行的ext.kotlin_version是否是最新Kotlin版本。

20.2.3 第一个协程程序
协程是轻量级的线程，因此协程也是由主线程管理的，如果主线程结束那么协程也就结束了。下面看看第一个协程示例：
//代码文件：chapter20/src/main/kotlin/com/a51work6/section2/ch20.2.3.kt
package com.a51work6.section2

import kotlinx.coroutines.experimental.delay
import kotlinx.coroutines.experimental.launch
import java.lang.Math.random
import java.lang.Thread.sleep

fun main(args: Array) {
launch { //启动一个协程 ①
for (i in 0…9) {
// 打印协程执行次数
println(“子协程执行第${i}次”)
// 随机生成挂起时间
val sleepTime = (1000 * random()).toLong()
// 协程挂起
delay(sleepTime) ②
}
println(“子协程执行结束。”)
}
sleep(10000L) // 主线程休眠，保持其他线程处于活动状态 ③
println(“主协程结束。”)

}
运行结果如下：
子协程执行第0次
子协程执行第1次
子协程执行第2次
子协程执行第3次
子协程执行第4次
子协程执行第5次
子协程执行第6次
子协程执行第7次
子协程执行第8次
子协程执行第9次
子协程执行结束。
主协程结束。
上述代码第①行launch函数创建并启动一个协程，类似于线程的thread函数。代码第②行是delay函数是挂起协程，类似于线程的sleep函数，但不同的是delay函数不会阻塞线程，而sleep函数会阻塞线程。代码第③行是让主线程休眠10秒，如果这里主线程不休眠，主线程直接就结束了，其他的线程或协程没有机会运行。

20.2.4 launch函数与Job对象
在上一节的示例中用到了launch函数是非常重要的，它的定义如下：
fun launch(
context:CoroutineContext = DefaultDispatcher,
start:CoroutineStart = CoroutineStart.DEFAULT,
block: suspend CoroutineScope.() -> Unit
): Job
context参数是协程上下文对象默认在DefaultDispatcher，DefaultDispatcher通常是一个公共线程池。start参数设置协程启动，block参数是协程体，类似于线程体，协程执行的核心代码在此编写，在协程体中执行的函数应该都是挂起函数，例如delay函数就是挂起的。
launch函数的返回是一个Job对象，Job是协程要执行的任务，可以将Job对象看做协程本身，所有对协程的操作都是通过Job对象完成的，协程的状态和生命周期都是通过Job反映出来的。

Job对象中常用的属性和函数如下：
o isActive属性。判断Job是否处于活动状态。
o isCompleted属性。判断Job是否处于完成状态。
o isCancelled属性。判断Job是否处于取消状态。
o start函数。开始Job。
o cancel函数。取消Job。
o join函数。是当前协程处于等待状态，直到Job完成，join是一个挂起函数只能在协程体中或其他的挂起函数中调用。
示例代码如下：
//代码文件：chapter20/src/main/kotlin/com/a51work6/section2/ch20.2.4.kt
package com.a51work6.section2

import kotlinx.coroutines.experimental.delay
import kotlinx.coroutines.experimental.launch
import java.lang.Math.random
import java.lang.Thread.sleep

fun main(args: Array) {
val job =launch { ①
//启动一个协程
for (i in0…9) {
// 打印协程执行次数
println(“子协程执行第${i}次”)
// 随机生成挂起时间
val sleepTime = (1000 * random()).toLong()
// 协程挂起
delay(sleepTime)
}
println(“子协程执行结束。”)
}
println(job.isActive) //true ②
println(job.isCompleted)//false ③
sleep(10000L) // 主线程休眠，保持其他线程处于活动状态
println(“主协程结束。”)
println(job.isCompleted) //true ④
}
上述代码第①行调用launch函数创建并开始一个协程，并返回Job对象赋值给job变量。代码第②行是判断job是否处于活动状态，代码第③行是判断job是否处于完成状态，由于协程还没有执行完成，因此这里返回false。代码第④行是返回true。

20.2.5 使用runBlocking函数
为了保持保持其他线程处于活动状态，前面两节示例中都使用sleep函数。sleep函数是线程提供的函数，在协程中最好不要使用，应该使用协程自己的delay函数，但delay是挂起函数，必须在协程体中或其他的挂起函数中使用。
修改20.2.3节示例代码如下：
//代码文件：chapter20/src/main/kotlin/com/a51work6/section2/ch20.2.5.kt
package com.a51work6.section2

import kotlinx.coroutines.experimental.delay
import kotlinx.coroutines.experimental.launch
import kotlinx.coroutines.experimental.runBlocking
import java.lang.Math.random

fun main(args: Array) = runBlocking { ①
val job = launch {
//启动一个协程
for (i in 0…9) {
// 打印协程执行次数
println(“子协程执行第${i}次”)
// 随机生成挂起时间
val sleepTime = (1000 *random()).toLong()
// 协程挂起
delay(sleepTime)
}
println(“子协程执行结束。”)
}
delay(10000L) // 主协程挂起 ②
println(“主协程结束。”)
}
上述代码第①行是将main代码放到runBlocking函数中，runBlocking函数也是启动并创建一个协程，可以与顶层函数一起使用。代码第②行是使用delay函数挂起主协程。

20.2.6 挂起函数
如果需要开发人员也可以编写的挂起函数，其实也很简单就在函数声明时候使用suspend关键字，示例如下：
suspend fun run() {
…
}

fun main(args: Array) {
run()
}
挂起函数不仅可以是顶层函数，还可以是成员函数，还可以是抽象函数，子类重写挂起函数后还应该是挂起的。示例代码如下：
abstract class SuperClass {
suspend abstract fun run()
}

class SubClass : SuperClass() {
override suspend fun run() {}
}
上述代码SubClass类实现了抽象类SuperClass的抽象挂起函数run，重写后它还是挂起函数。
示例代码如下：
//代码文件：chapter20/src/com/a51work6/section4/ch20.2.6.kt
package com.a51work6.section2
…
suspend fun run(name: String) { ①
//启动一个协程
for (i in 0…9) {
// 打印协程执行次数
println(“子协程$name执行第${i}次”)
// 随机生成挂起时间
val sleepTime = (1000 *random()).toLong()
// 协程挂起
delay(sleepTime)
}
println(“子协程${name}执行结束。”)
}

fun main(args: Array) = runBlocking {
//启动一个协程1
val job1 = launch() { ②
run(“job1”) ③
}
//启动一个协程2
val job2 = launch { ④
run(“job2”) ⑤
}
delay(10000L) // 主协程挂起
println(“主协程结束。”)
}

运行结果如下：
子协程job1执行第0次
子协程job2执行第0次
子协程job1执行第1次
子协程job2执行第1次
子协程job1执行第2次
子协程job1执行第3次
子协程job1执行第4次
子协程job1执行第5次
子协程job2执行第2次
子协程job2执行第3次
子协程job1执行第6次
子协程job1执行第7次
子协程job2执行第4次
子协程job1执行第8次
子协程job2执行第5次
子协程job2执行第6次
子协程job1执行第9次
子协程job2执行第7次
子协程job1执行结束。
子协程job2执行第8次
子协程job2执行第9次
子协程job2执行结束。
主协程结束。
上述代码第①行是声明一个挂起函数，代码第②行和第③行是创建创建并启动两个协程，在它们的协程体中分别调用run函数。

20.3 协程生命周期

在协程的生命周期是通过Job的几种状态体现的，如图20-1所示，Job协程有6种状态。下面分别介绍一下。
1．新建状态
新建状态是主要是通过launch函数创建协程对象，它仅仅是一个空的协程对象。
2．活动状态
新建协程调用start函数后，它就进入活动状态。launch函数通过start参数设置是否启动协程。处于活动状态的协程会执行协程体。
3．正在完成状态
正在完成状态是一个瞬间过渡状态，从活动状态进入到已完成状态时经历的中间状态。
4．已完成状态
协程成功执行协程体完，就会进入已完成状态，这是最终状态，说明这个协程已经停止。
5．正在取消状态
活动状态或正在完成状态时，如果调用了cancel函数则会进入已取消状态，在此之前要先进入正在取消状态，正在取消状态也是一个瞬间过渡状态。
6．已取消状态
在新建状态、活动状态或正在完成状态时，如果调用了cancel函数最终都会已取消状态，只是新建状态没有经历正在取消状态，而是直接已取消状态。已取消状态是最终状态，说明这个协程已经停止。

Job状态可以通过Job的isActive、isCompleted和isCancelled属性判断而知。具体说明参见表20-1。

20.4 管理协程

管理协程是比管理线程简单多了，本节介绍几个管理协程的常用函数。

20.4.1 等待协程结束
前面提到过join函数，协程的join函数与线程的join函数类似。如果在当前协程中调用job1协程的join函数，则会阻塞当前协程，直到job1协程结束当前协程才会继续运行状态。
示例代码如下：
//代码文件：chapter20/src/com/a51work6/section4/ch20.4.1.kt
package com.a51work6.section4

import kotlinx.coroutines.experimental.launch
import kotlinx.coroutines.experimental.runBlocking

//共享变量
var value = 0 ①

fun main(args: Array) = runBlocking {

println("主协程开始...")
// 创建协程job1
val job1 = launch {    ②
    println("子协程开始...")
    for (i in 0..1) {
        println("子协程执行...")
        value++      ③
    }
    println("子协程结束...")
}
// 主协程被挂起，等待job1协程结束
job1.join()                 ④
println("value = $value")  ⑤
println("主协程结束...")

}
运行结果如下：
主协程开始…
子协程开始…
子协程执行…
子协程执行…
子协程结束…
value = 2
主协程结束…

上述代码第①行是声明了一个共享变量value，这个变量在子协程中修改，然后主协程访问它。代码第②行是创建并启动协程job1。代码第③行是在子协程中修改共享变量value。
代码第④行是在当前协程（主协程）中调用job1的join函数，因此会导致主协程挂起，等待job1协程结束，从运行结果可以看出主协程被挂起了。代码第⑤行是打印共享变量value，从运行结果可见value = 2。
如果尝试将job1.join()语句注释掉，输出结果如下：
主协程开始…
value = 0
主协程结束…
从运行结果看，如果一个主协程没有挂，子协程根本没有机会运行，程序就直接结束了。

20.4.2 超时设置
协程在挂起时有时需要设置超时限制，设置超时使用withTimeout函数。示例代码如下：
//代码文件：chapter20/src/com/a51work6/section4/ch20.4.2.kt
package com.a51work6.section4

import kotlinx.coroutines.experimental.delay
import kotlinx.coroutines.experimental.runBlocking
import kotlinx.coroutines.experimental.withTimeout

suspend fun run(name: String) {
//启动一个协程
for (i in 0…9) {
// 打印协程执行次数
println(“子协程$name执行第${i}次”)
// 随机生成挂起时间
val sleepTime = (1000 *Math.random()).toLong()
// 协程挂起
delay(sleepTime)
}
println(“子协程${name}执行结束。”)
}

fun main(args: Array) = runBlocking {
//启动一个协程1
withTimeout(2000L) { ①
run(“job1”)
}
println(“主协程结束。”)
}
执行结果如下：
子协程job1执行第0次
子协程job1执行第1次
子协程job1执行第2次
子协程job1执行第3次
子协程job1执行第4次
Exception in thread “main” kotlinx.coroutines.experimental.TimeoutCancellationException:
Timed out waiting for 2000 MILLISECONDS
at kotlinx.coroutines.experimental.ScheduledKt.TimeoutCancellationException(Scheduled.kt:185)
at
…
上述代码第①行调用withTimeout函数，设置超时时间为2秒，超过2秒抛出异常，需要执行的协程体放到withTimeout{…}中，withTimeout也会创建并启动一个协程，但它的返回的不是Job对象。

20.4.3 取消协程
协程体结束，协程进入完成状态，协程就停止了。但是有些业务比较复杂，例如想开发一个下载程序，每隔一段执行一次下载任务，下载任务一般会在由子协程执行的，挂起一段时间再执行。这个下载子协程中会有一个死循环，但是为了能够停止子协程，可以调用cancel函数或cancelAndJoin函数取消协程。
示例代码如下：
//代码文件：chapter20/src/com/a51work6/section4/ch20.4.3.kt
package com.a51work6.section4

import kotlinx.coroutines.experimental.delay
import kotlinx.coroutines.experimental.launch
import kotlinx.coroutines.experimental.runBlocking

fun main(args: Array) = runBlocking {
// 创建协程
val job = launch {
// 一直循环，直到满足条件在取消协程
while (true) { ①
// 协程开始工作
// TODO
println(“下载中…”)
delay(10000L)
}
}

val command =readLine()// 读取从键盘的字符串          ②
if (command =="exit") {       

job.cancel()//取消协程 ③
job.join()//等待协程结束
//job.cancelAndJoin()//取消协程并等待协程job结束 ④
}

}
上述代码第①行是设置while循环一直执行协程体，直到有程序取消它。代码第②行读取从键盘的字符串，如果输入的是exit，则取消协程。代码第③行是取消协程，取消协程往往需要调用join等待job协程结束，否则可能会出现job还没有结束，主协程已经结束。如果两个函数都调用也可以使用cancelAndJoin函数替代，见代码第④行。

本章小结

本章介绍了Kotlin协程技术，其中重点介绍了kotlinx.coroutines框架。读者需要重点掌握如何创建协程、协程状态和协程管理等内容，其中创建协程和协程管理是学习的重点。