Kotlin协程Job生命周期结构化并发详解
前面在学习协程启动方式的时候在launch的源码中有一个返回值是Job，async的返回Deferred也是实现了Job，那么而也就是说launch和async在创建一个协程的时候也会创建一个对应的Job对象。还提到过Job是协程的句柄，那么Job到底是什么？它有什么用？
1.Job的生命周期
先看一下Job的源码，这里只保留了跟标题相关的内容
public interface Job : CoroutineContext.Element {
// ------------ 状态查询API ------------
public val isActive: Boolean
public val isCompleted: Boolean
public val isCancelled: Boolean
// ------------ 操控状态API ------------
public fun start(): Boolean
public fun cancel(cause: CancellationException? = null)
public fun cancel(): Unit = cancel(null)
public fun cancel(cause: Throwable? = null): Boolean
// ------------ 等待状态API ------------
public suspend fun join()
// ------------ 完成状态回调API ------------
public fun invokeOnCompletion(handler: CompletionHandler): DisposableHandle
public fun invokeOnCompletion(
onCancelling: Boolean = false,
invokeImmediately: Boolean = true,
handler: CompletionHandler): DisposableHandle
}
复制代码从源码中可以发现这几个函数和变量跟Actviity或者Fragment非常像，所以我们可以总结出两个结论：
- Job可以监测协程的生命周期
- Job可以操控协程
在例子中使用这几个函数和变量再来校验一下上面的结论：
fun main() = runBlocking {
val job = launch {
delay(1000L)
}
job.log()
job.cancel()
job.log()
}
fun Job.log() {
println(
"""
isActive：$isActive
isCompleted：$isCompleted
isCancelled：$isCancelled
Thread：${Thread.currentThread().name}
================================
""".trimIndent()
)
}
//输出结果
//isActive：true
//isCompleted：false
//isCancelled：false
//Thread：main @coroutine#1
//================================
//isActive：false
//isCompleted：false
//isCancelled：true
//Thread：main @coroutine#1
//================================
复制代码Job.log用了扩展函数，方便调用Job中的状态监测返回值。
上面的代码通过launch创建了一个协程，接收了Job的返回值，这里用这个job对象做了三件事：
- 第一个
job.log()：launch的创建标志着协程已经被启动所以在第一个job.log()的日志中isActive返回值是true； job.cancel()： 这里调用了job的取消函数将协程任务取消；- 第二个
job.log()： 上面的代码将协程任务取消了，然后再次获取协程状态发现isActivte返回false，isCancelled返回true。
上面的代码也印证了前面提出的结论，还有一个函数start没使用，再来调用它之后输出的日志：
fun main() = runBlocking {
//变化1
val job = launch(start = CoroutineStart.LAZY) {
delay(1000L)
}
job.log()
//变化2
job.start()
job.log()
job.cancel()
job.log()
}
fun Job.log() {
println(
"""
isActive：$isActive
isCompleted：$isCompleted
isCancelled：$isCancelled
Thread：${Thread.currentThread().name}
================================
""".trimIndent()
)
}
//输出结果：
//isActive：false
//isCompleted：false
//isCancelled：false
//Thread：main @coroutine#1
//================================
//isActive：true
//isCompleted：false
//isCancelled：false
//Thread：main @coroutine#1
//================================
//isActive：false
//isCompleted：false
//isCancelled：true
//Thread：main @coroutine#1
//================================
复制代码上面的代码增加了两处修改：
- 变化1：协程在创建出来的时候就已经被启动，因此为了查看调用
Job.start()前的日志需要加上懒启动 - 变化2：调用
start函数启动协程
从输出结果来看没有调用start函数前isActive返回true，调用后就返回了true，当使用懒启动后在调用cancel函数与前面使用cancel函数输出的日志是一样的，可以得知懒启动后对协程的生命周期并没有设么影响(这可能是句废话)。
现在还有最后一个变量没有看isCompleted，在上面的代码中添加一个延时函数，等协程任务结束再打印日志
fun main() = runBlocking {
val job = launch(start = CoroutineStart.LAZY) {
delay(1000L)
}
job.log()
job.start()
job.log()
job.cancel()
delay(2000L) //变化在这里
job.log()
}
fun Job.log() {
println(
"""
isActive：$isActive
isCompleted：$isCompleted
isCancelled：$isCancelled
Thread：${Thread.currentThread().name}
================================
""".trimIndent()
)
}
//输出结果：
//isActive：false
//isCompleted：false
//isCancelled：false
//Thread：main @coroutine#1
//================================
//isActive：true
//isCompleted：false
//isCancelled：false
//Thread：main @coroutine#1
//================================
//isActive：false
//isCompleted：true
//isCancelled：true
//Thread：main @coroutine#1
//================================
复制代码从输出结果中看到当调用isCancel后isCompleted也返回了true，也就是说任务结束了。
上面的代码为了监测isCompleted的状态加了一个延时函数delay，但是这种方式并不建议使用，因为这个时间他不是固定的，例如从后台请求数据或者下载文件，这种情况下的时间是完全无法预知的。
现在假设已经知道协程执行完毕需要delay(1000L)的时间，如果将协程内的delay时长设置的大于外部的delay时长，会带来什么问题？
fun main() = runBlocking {
val job = launch(start = CoroutineStart.LAZY) {
delay(4000L)
}
job.log()
job.start()
job.log()
delay(1000L)
job.log()
println("Process end!")
}
fun Job.log() {
println(
"""
isActive：$isActive
isCompleted：$isCompleted
isCancelled：$isCancelled
Thread：${Thread.currentThread().name}
================================
""".trimIndent()
)
}
//输出结果：
//isActive：false
//isCompleted：false
//isCancelled：false
//Thread：main @coroutine#1
//================================
//isActive：true
//isCompleted：false
//isCancelled：false
//Thread：main @coroutine#1
//================================
//isActive：true
//isCompleted：false
//isCancelled：false
//Thread：main @coroutine#1
//================================
//Process end!
复制代码由输出结果可知isCompleted状态是false，协程任务是否执行完毕不得而知。另外当println("Process end!")执行完毕后程序并没有立即输出Process finished with exit code 0，这是因为runBlocking 会一直阻塞，等到 job 任务执行完毕以后才真正退出。
那要如何解决这个问题？
//Job#join
public suspend fun join()
复制代码join是Job中的一个挂起函数，调用后会挂起当前程序的执行流程，等待job当中的协程任务执行完毕然后再恢复当前程序的执行流程。
join将任务挂起后再恢复，那要如何知道任务是否执行完毕了？invokeOnCompletion可以监听任务执行的状态
//Job#invokeOnCompletion
public fun invokeOnCompletion(handler: CompletionHandler): DisposableHandle
//Job#invokeOnCompletion
public fun invokeOnCompletion(
onCancelling: Boolean = false,
invokeImmediately: Boolean = true,
handler: CompletionHandler): DisposableHandle
复制代码join和invokeOnCompletion的使用如下：
fun main() = runBlocking {
val job = launch(start = CoroutineStart.LAZY) {
delay(4000L)
}
job.log()
job.start()
job.log()
//新增
job.join()
//新增
job.invokeOnCompletion {
println("==========Task status==========")
job.log()
}
println("Process end!")
}
fun Job.log() {
println(
"""
isActive：$isActive
isCompleted：$isCompleted
isCancelled：$isCancelled
Thread：${Thread.currentThread().name}
================================
""".trimIndent()
)
}
//输出结果：
//isActive：false
//isCompleted：false
//isCancelled：false
//Thread：main @coroutine#1
//================================
//isActive：true
//isCompleted：false
//isCancelled：false
//Thread：main @coroutine#1
//================================
//==========Task status==========
//isActive：false
//isCompleted：true
//isCancelled：false
//Thread：main @coroutine#1
//================================
//Process end!
复制代码可以看到加入join和invokeOnCompletion之后isCompleted的状态就正确了，同时Process end!输出后Process finished with exit code 0也会很快的输出，这说明任务确实执行完毕了。
在讲协程的启动方式的时候提出一个观点：launch的返回值Job代表的是协程的句柄。那么Job是协程的句柄该怎么理解？
句柄： 是指一个中间媒介，可以操控一个东西。就类似于遥控器操作空调场景中遥控器就是句柄，开关控制灯具场景中开关就是句柄。
所以Job和协程的关系就类似于遥控器和空调，开关和灯具。Job可以监测协程的运行状态也可以控制协程的运行状态。那么Job就和遥控器、开关一样看做是一个句柄。
2.Deffered
launch直接创建了Job，async通过Deffered间接创建了Job对象，但是它并没有在 Job 的基础上扩展出很多其他功能，而接收一个返回值是依靠 await() 方法，那await方法是如何实现的？
fun main() = runBlocking {
val deferred = async {
logX("Coroutine start!")
delay(1000L)
logX("Coroutine end!")
"Coroutine result!"
}
val result = deferred.await()
println("Result = $result")
logX("Process end!")
}
fun logX(any: Any?) {
println(
"""
================================
$any
Thread:${Thread.currentThread().name}
================================
""".trimIndent()
)
}
//输出结果：
//Coroutine start!
//Thread:main @coroutine#2
//================================
//================================
//Coroutine end!
//Thread:main @coroutine#2
//================================
//Result = Coroutine result!
//================================
//Process end!
//Thread:main @coroutine#1
复制代码从输出结果来看，await方法可以获取协程执行结果外，好像还会阻塞协程的执行流程，直到协程任务执行完毕。看一下await的源码
//Deferred#await
public interface Deferred<out T> : Job {
...
public suspend fun await(): T
...
}
复制代码从源码来看await也是一个挂起函数，它跟join是一样的，看似阻塞的过程其实是协程的挂起和恢复能力。
所以，总的来说，Deferred 只是比 Job 多了一个 await() 挂起函数而已，通过这个挂起函数，就可以等待协程执行完毕的同时，还可以直接拿到协程的执行结果。
3.Job与结构化并发
在其他地方看过这么一句话：协程的优势在于结构化并发， 这句话该如何理解？
这句话可以理解为带有结构和层级的并发，用代码表现就像这样：
fun main() = runBlocking {
val parentJob: Job
var childJob1: Job? = null
var childJob2: Job? = null
var childJob3: Job? = null
parentJob = launch {
childJob1 = launch {
delay(1000L)
}
childJob2 = launch {
delay(3000L)
}
childJob3 = launch {
delay(5000L)
}
}
delay(500L)
parentJob.children.forEachIndexed { index, job ->
when (index) {
0 -> println("childJob1 === childJob1 is ${childJob1 === job}")
1 -> println("childJob2 === childJob2 is ${childJob2 === job}")
2 -> println("childJob3 === childJob3 is ${childJob3 === job}")
}
}
parentJob.join()
logX("Process end!")
}
//输出结果：
//childJob1 === childJob1 is true
//childJob2 === childJob2 is true
//childJob3 === childJob3 is true
//================================
//Process end!
//Thread:main @coroutine#1
复制代码上面的代码是父子层级，父Job使用launch启动了协程同时它的内部还有三个Job，三个子Job是并发执行的，同时也是用过launch启动的协程，调用了parentJob.join()那么挂起的时间就是childJob3的时长—5秒，因为它要等待所有任务都执行完毕才会恢复执行，然后通过children.forEachIndexed进行遍历并分别对比他们与三个子Job的引用是否相等“===”代表了引用相等，即是否是同一个对象）。图示如下
前面讲过，Job可以调用cancel方法取消执行，那么当调用parentJob.cancel会有什么样的情况？
fun main() = runBlocking {
val parentJob: Job
var childJob1: Job? = null
var childJob2: Job? = null
var childJob3: Job? = null
parentJob = launch {
childJob1 = launch {
println("childJob1 start")
delay(1000L)
println("childJob1 end")
}
childJob2 = launch {
println("childJob2 start")
delay(3000L)
println("childJob2 start")
}
childJob3 = launch {
println("childJob3 start")
delay(5000L)
println("childJob3 start")
}
}
delay(500L)
parentJob.cancel()
logX("Process end!")
}
//输出结果：
//childJob1 start
//childJob2 start
//childJob3 start
//================================
//Process end!
//Thread:main @coroutine#1
复制代码parentJob.cancel调用后，每个子Job只是输出了start，这就可以得出一个结论：父Job取消后子Job也会依次跟着取消。如果调用任何一个子Job的cancel则不会对父Job和其他子Job产生影响。
到这里对于开头的那句协程的优势在于结构化并发就有更更好的理解了，这是Kotlin协程的第二大优势。
4.launch和async的使用场景
- launch： 主要用来发起一些不需要任何结果的耗时任务，这个任务在执行中可以改变它的执行状态。
- async： 主要用来发起一些需要结果的耗时任务，以及与挂起函数结合，优化并发。
以上就是Kotlin协程Job生命周期结构化并发详解的详细内容，更多关于Kotlin协程Job的资料请关注编程网其它相关文章！
免责声明：
① 本站未注明“稿件来源”的信息均来自网络整理。其文字、图片和音视频稿件的所属权归原作者所有。本站收集整理出于非商业性的教育和科研之目的，并不意味着本站赞同其观点或证实其内容的真实性。仅作为临时的测试数据，供内部测试之用。本站并未授权任何人以任何方式主动获取本站任何信息。
② 本站未注明“稿件来源”的临时测试数据将在测试完成后最终做删除处理。有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341
