一.保持对协程的追踪
我们知道协程可以处理耗时任务，但是假如我们的项目中开启了一千个协程处理任务，我们都是通过手动去追踪它们，那代码很容易出错。也很容易失去对协程的实时跟踪。就会引起work leak，任务泄漏，类似内存泄漏一样，任务泄漏会导致CPU，内存，磁盘资源被占用。甚至会发起一些无用的网络请求。为了避免任务的泄漏，Kotlin引入了结构化并发机制。
在Android平台使用结构化并发可以做到以下三件事：
（1）取消任务——当任务不需要继续执行的时候，取消他
（2）追踪任务——当任务正在执行的时候追踪他
（3）发出错误的信号——当协程执行失败时，发出错误信号表明有错误发生
二.借助scope 来取消任务
scope在协程中称为作用域，协程的运行必须指定作用域，CoroutineScope（作用域）可以对协程进行追踪，即使协程被挂起也是如此。CoroutineScope并不运行协程，他只是确保实时跟着协程的运行。因此在Kotlin中不允许在没有作用域的情况下启动新的协程。作用域可以跟踪所有的协程，有可以取消由它启动的协程。在Android开发中经常用到。比如在一个Activity中启动一个协程，当Activity关闭的时候，取消协程的执行。这个时候我们可以联想到让我们Activity的生命周期保持和作用域的生命周期一样。以上总结就是：作用域（CoroutineScope ）会跟踪所有的协程，并可以取消由它启动的协程。
三.协程的启动方式
启动协程，必须要在作用域内，而启动协程的方式有两种：
（1）launch构建器——启动新的协程而不将结果返回给调用方
（2）async构建器——启动新的协程，通过await的挂起函数返回result
如：以下launch启动的协程，我们只是在挂起函数doSomthingOne中拿到了返回值。
package com.example.kotlin01
import kotlinx.coroutines.*
suspend fun main() {
runBlocking {
var job = launch {
var result1 = doSomthingOne()
println(result1)
}
}
}
suspend fun doSomthingOne(): Int {
delay(2000)
return 13
}
13
如：以下async启动的协程，我们通过返回调用await拿到返回值。
package com.example.kotlin01
import kotlinx.coroutines.*
suspend fun main() {
runBlocking {
var job = async {
doSomthingOne()
}
println(job.await())
}
}
suspend fun doSomthingOne(): Int {
delay(2000)
return 13
}
13
四.在 ViewModel 中启动协程
项目中经常我们通过使用jetpack中的ViewModel组件来作为View的控制器和Activity绑定起来，这样以来我们知道即使当我们的手机屏幕旋转Activity异常销毁重建的时候我们的Viewmodel也不会销毁。如果我们在ViewModel中启动协程，我们的协程也不会因此而被终止。我们知道协程都是运行在作用域中的，所以就产生了我们的ViewModel.viewModelScope。当viewModelScope被清除，调用onCleared的时候，我们的协程也就取消执行了。比如当一个接口正在请求数据的时候，此时用户关闭了应用，那么我们的请求就应该被取消掉。当一个协程中又启动了一个新的协程，那他们都公用父协程的作用域。viewModelScope的使用实例
package com.example.kotlin01
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import kotlinx.coroutines.launch
class MyViewModel : ViewModel() {
fun runForever() {
// 在 ViewModel 中启动新的协程
viewModelScope.launch {
// 当 ViewModel 被清除后，下列代码也会被取消
while (true){
println("你好")
}
}
}
}
我们看到我们在协程体中写了一个死循环，但是假如我们的Viewmodel被清除的时候，协程也会被取消。死循环中的代码也会取消执行。
五.任务追踪
有时候我们会遇到一些更复杂的问题，比如在一个协程中处理多个网络请求，我们可以作在一个协程中又启动多个协程去执行任务，但是如果随意启动协程，就会容易引起任务泄漏，调用方可能感知不到启动了新的协程，也就无法追踪。为了解决这个问题，结构化并发保证了supend函数返回时，处理任务也都完成。我们使用coroutineScope或者supervisorScope构造器在supend函数中启动新的协程，确保了supend函数返回的时候，他们所做的任务也都能结束。
suspend fun fetchTwoDocs() {
coroutineScope {
launch { fetchDoc(1) }
async { fetchDoc(2) }
}
}
以上suspend函数fetchTwoDocs中使用了coroutineScope构造器启动了两个协程，当fetchTwoDocs函数返回的时候，确保了launch和async启动的协程也都已经完成执行。
六.任务追踪（处理一堆任务）
在以上的例子中，假如我们在supend函数中启动了一千个协程，那么是否还能正常追踪呢，结果也是一样的。coroutineScope构造器启动的协程会等待协程中的任务执行完成，supend函数才会返回。并且coroutineScope还会创建一个子scope（作用域），我们知道supend函数肯定是由某个协程内部调用的，运行在某个作用域内，那么suspend函数中通过coroutineScope启动的协程会创建一个子作用域scope ，这个子作用域继承了suspend函数所在协程的作用域（父作用域）。假如这个父作用域是一个viewScope，当用户离开界面，关闭Activity的时候，viewScope被清除，那么所有的子作用域也会被清楚。子作用域内的协程也会被取消执行。这样就不会造成了任务泄漏。
七.协程失败时发出报错信号
val unrelatedScope = MainScope()
// 丢失错误的例子
suspend fun lostError() {
// 未使用结构化并发的 async
unrelatedScope.async {
throw InAsyncNoOneCanHearYou("except")
}
}
以上我们在supend函数中声明了一个无关联的作用域，它不会按照结构化并发的方式启动新的协程，这段代码的错误将丢失，因为异常通过去获取，而我们并没有调用await 。所以这个错误将永远不会得到处理。
使用结构化并发
suspend fun foundError() {
coroutineScope {
async {
throw StructuredConcurrencyWill("throw")
}
}
}
使用结构化并发就是在supend函数中使用coroutineScope构造器启动协程，coroutineScope将会创建子作用域继承了supend函数所在协程的作用域。如果coroutineScope创建的协程抛出了异常，coroutineScope将会抛给调用方，因为我们使用的是coroutineScope而不是supervisorScope，当抛出异常的时候，所有的子任务就会被取消。
八.理解结构化并发
package com.example.kotlin01
import kotlinx.coroutines.*
suspend fun main() {
println("${doSum()}")
}
suspend fun doSum(): Int = coroutineScope {
var result1 = async { doSomthingOne() }
var result2 = async { doSomthingTwo() }
result1.await() + result2.await()
}
suspend fun doSomthingOne(): Int {
delay(2000)
println("doSomthingOne")
return 13
}
suspend fun doSomthingTwo(): Int {
delay(1000)
println("doSomthingTwo")
return 15
}
在supend 函数中我们通过coroutineScope 构造器启动了两个协程调用doSomthingOne，doSomthingTwo，因为coroutineScope 启动的协程的作用域都继承了supend函数所在协程的作用域，当doSomthingOne函数出现异常的时候，会抛给父作用域，父作用域下协程的的子协程都会被取消。也就是doSomthingOne和doSomthingTwo都会被取消。
