定义
协程基于线程，是轻量级的线程
作用
- 处理耗时任务，这种任务常常会阻塞主线程
- 保证主线程安全，即确保安全地从主线程调用任何suspend函数
特点
- 让异步逻辑同步化
- 最核心的点就是，函数或者一段程序能够被挂起，稍后再在挂起得位置恢复
挂起函数
- 使用suspend关键字修饰的函数
- 挂起函数只能在协程体内或其他挂起函数内调用
挂起和阻塞的区别
- 挂起不会阻塞主线程，主线程可以正常刷新UI，但阻塞就会导致主线程ANR
协程调度器
- Dispatchers.Main：主线程上处理UI交互相关，更新LiveData
- Dispatchers.IO：非主线程，磁盘读写和网络IO
- Dispatchers.Default：非主线程，CPU密集型任务，排序，JSON数据解析等
任务泄漏
- 当某个协程任务丢失，无法追踪，会导致内存、CPU、磁盘等资源浪费，甚至发送一个无用的网络请求，这种称为任务泄漏
- 为了避免，引入了结构化并发机制
结构化并发
- 可以取消任务、追踪任务、协程失败时发出错误信号
协程作用域CoroutineScope
- 可以追踪所有协程，也可以取消协程
- GlobalScope:生命周期是Process级别，即使Activity或Fragment已经被销毁，协程仍然运行
- MainScope：在activity中使用，可以在onDestroy中取消协程
- ViewModelScope：只能在ViewModel中使用，绑定ViewModel生命周期
- lifecycleScope：只能在Activity、Fragment中使用，会绑定Activity、Fragment的生命周期
协程构建器
launch和async构建器都用来启动新协程
- launch，返回一个Job并且不附带任何结果
- async，返回一个Deferred，Deferred也是一个Job，可以使用.await()在一个延期的值上得到最终的结果
- launch 是非阻塞的 而 runBlocking 是阻塞的。多个 withContext 任务是串行的， 且withContext 可直接返回耗时任务的结果。 多个 async 任务是并行的，async 返回的是一个Deferred<T>，需要调用其await()方法获取结果
- runBlocking一般用在测试中，会阻塞当前线程，会等到包裹的子协程都执行完毕才退出
- 事实上await()也不一定导致协程会被挂起，await() 只有在 async 未执行完成返回结果时，才会挂起协程。若 async 已经有结果了，await() 则直接获取其结果并赋值给变量，此时不会挂起协程
| 构建器 | 是否立即启动？ | 串行？并行？ | 是否阻塞当前线程？ | 返回结果 |
|---|---|---|---|---|
| launch | 是 | 根据包裹的子协程类型而定 | 否 | Job对象 |
| async | 是 | 任务之间是并行 | 否 | Deferred，可以用await()方法获取结果 |
| runBlocking | 是 | 根据包裹的子协程类型而定 | 阻塞 | 子协程都执行完毕后才退出 |
| withContext | 不是 | 任务之间是串行 | 否 | 可以直接返回耗时任务结果，协程体最后一行内容 |
doAsync和async
- doAsync 的源码它的实现都是基于Java的 Future 类进行异步处理和通过Handler进行线程切换 ，从而封装的一个扩展函数方便线程切换。
- 与 async 关系不大，因为 doAsync并没有用到协程库中的东西
- 可以通过 uiThread { } 来切换会主线程
btn.setOnClickListener {
doAsync {
Log.e("TAG", " doAsync... [当前线程为：${Thread.currentThread().name}]")
uiThread {
Log.e("TAG", " uiThread.... [当前线程为：${Thread.currentThread().name}]")
}
}
}
Job对象的生命周期
- 每一个通过launch或者async创建的协程，都会返回一个Job实例，该实例时协程的唯一标识，负责管理协程的生命周期
- 一个任务包含一系列状态：新创建（New）、活跃（Active）、完成中（Completing）、已完成（Completed）、取消中（Canceling）和已取消（Cancelled）。我们无法直接访问这些状态，可以通过访问Job的属性：isActive、isCancelled和isCompleted
- 如果协程处于活跃状态，协程运行出错或是调用job.cancel()，都会将当前任务置为取消中（Cancelling）状态（isActive=false，isCancelled=true）。当所有子协程都完成后，协程会进入已取消（Cancelled）状态，此时isCompleted=true
- 协程完成，可能是正常完成，也可能是被取消了
等待一个作业
由launch启动的协程用join()方法；用async启动的协程用await()
@Test
fun `test coroutine join`() = runBlocking {
val job1 = launch {
delay(200)
println("job1 finished")
}
//这样可以确保job1执行完再执行后面的job2和job3
job1.join()
val job2 = launch {
delay(200)
println("job2 finished")
//返回结果
"job2 result"
}
val job3 = launch {
delay(200)
println("job3 finished")
//返回结果
"job2 result"
}
}
组合并发
@Test
fun `test async`() = runBlocking {
val time = measureTimeMillis {
val one = doOne()
val two = doTwo()
//输出是30
println("result: ${one + two}")
}
//输出是2秒多，也就是是串行的
println(time)
}
//并发
@Test
fun `test combine async`() = runBlocking {
val time = measureTimeMillis {
val one = async { doOne() }
val two = async { doTwo() }
//输出是30
println("result: ${one.await() + two.await()}")
}
//输出是1秒多，也就是是并行的
println(time)
}
private suspend fun doOne(): Int{
delay(1000)
return 10
}
private suspend fun doTwo(): Int{
delay(1000)
return 20
}
注意async的写法不能是：
val one = async { doOne() }.await()
val two = async { doTwo() }.await()
这样起不到并发效果，而是等到one执行完，再执行two
协程的启动模式
- DEFAULT：协程创建后，立即开始调度，在调度前如果协程被取消，其将直接进去取消响应状态
- ATOMIC：协程创建后，立即开始调度，协程执行到第一个挂起点之前不响应取消
需要注意的是，立即调度不等于立即执行
- LAZY：只有协程被需要时，包括主动调用协程的start、join或者await等函数时才会开始调度，如果调度前就被取消，那么该协程将直接进入异常结束状态
@Test
fun `test start mode`() = runBlocking {
val job = async(start = CoroutineStart.LAZY) {
//
}
//...其他代码
//启动协程
job.await()
}
- UNDISPATCHED：协程创建后立即在当前函数调用栈中执行，直到遇到第一个真正的挂起点
@Test
fun `test start mode`() = runBlocking {
val job = async(context = Dispatchers.IO, start = CoroutineStart.UNDISPATCHED) {
println("thread:"+ Thread.currentThread().name)
}
}
//上面输出的线程名字是主线程，因为UNDISPATCHED会立即在当前线程中执行，而runBlocking是在主线程中
协程作用域构建器 coroutineScope、runBlocking、supervisorScope
- runBlocking是常规函数，会阻塞当前线程；coroutineScope是挂起函数，不会阻塞当前线程
- 它们都会等待协程体以及所有子协程结束，一个是阻塞线程等待，一个是挂起等待
协程作用域构建器 coroutineScope、supervisorScope
- coroutineScope，一个协程失败了，所有其他兄弟协程也会被取消
- supervisorScope，一个子协程失败了，不会影响其他兄弟协程，但如果是作用域有异常失败了，则所有的子协程都会失败退出
coroutineScope和CoroutineScope
- coroutineScope是一个挂起函数，是协程作用域构建器，CoroutineScope()是一个普通函数
- coroutineScope后面的协程作用域的协程上下文是继承父协程作用域的上下文
- CoroutineScope()有自己的作用域上下文
- 都能够进行解构化并发，可以很好的管理多个子协程
协程的取消
- 取消作用域会取消它的子协程
- 被取消的子协程不会影响其余兄弟协程
- 协程通过抛出一个特殊的异常CancellationException来处理取消操作
- 所有kotlinx.coroutines中的挂起函数（withContext、delay等）都是可取消的
- CPU密集型任务无法直接用cancel来取消
CPU密集型任务的取消
- 通过isActive来判断取消，因为取消的任务isActive为false
- 通过ensureActive()来取消，如果被取消，任务isActive为false，会抛一个异常
- yield函数会检查所在协程的状态，如果已经取消，则抛出CancellationException予以响应。此外，它还会尝试出让线程的执行权，给其他协程提供执行的机会
协程取消的副作用
- 在finally中释放资源
@Test
fun `test release resources`() = runBlocking {
var br = BufferedReader(FileReader("xxx"))
with(br){
var line:String?
try {
while (true){
line = readLine() ?: break
println(line)
}
}finally {
//关闭资源
close()
}
}
}
- 用use函数：该函数只能被实现了Closeable的对象使用，程序结束的时候会自动调用close方法，适合文件对象
//use函数在文件使用完毕后会自动调用close函数
BufferedReader(FileReader("xxx")).use {
var line:String?
while (true){
line = readLine() ?: break
println(line)
}
}
不能取消的任务
协程被取消后，finally里面还有挂起函数，可以用withContext(NonCancellable)
@Test
fun `test cancel with noncancellable`() = runBlocking {
val job = launch {
try {
repeat(1000){
println("job: i'm sleeping $it")
delay(500L)
}
}finally {
//不用withContext(NonCancellable)，delay后面的打印不会执行
withContext(NonCancellable){
println("running finally")
delay(1000L)
println("job: noncancellable")
}
}
}
delay(1300)
println("main: waiting")
job.cancelAndJoin()
println("main: i can quit")
}
超时任务
withTimeout()方法可以开启超时任务，默认超时会抛出异常
/*
* 超时任务
* */
@Test
fun `test deal with timeout`() = runBlocking {
withTimeout(1300){
repeat(1000){
println("job: sleeping $it")
delay(500L)
}
}
}
如果不想抛出异常，可以用withTimeoutOrNull
/*
* 超时任务，超时会返回null，不超时返回最后的done
* */
@Test
fun `test deal with timeout ornull`() = runBlocking {
val result = withTimeoutOrNull(1300){
repeat(1000){
println("job: sleeping $it")
delay(500L)
}
"done"
}
println("result: $result")
}
