Kotlin协程取消

协程的取消

取消作用于会取消它的子协程
被取消的子协程并不会影响其余兄弟协程
协程通过跑出一个特殊的异常CancellationException来处理取消操作
所有kotlinx.coroutines中的挂起函数（withContext、delay等）都是可以取消的

fun testCancellationException()= runBlocking {
    val job1 = GlobalScope.launch {
        try {
            delay(1000)
            println("job 1")
        } catch(e: Exception) {
            e.printStackTrace()
        }
    }
    delay(100)
    job1.cancel()
    job1.join()
}

kotlinx.coroutines.JobCancellationException: 
StandaloneCoroutine was cancelled; job=StandaloneCoroutine{Cancelling}@ac54805

1.看以上代码 job1 延时了100毫秒 job1已经进入挂起了 cancel后会抛出一个异常不过该异常已经被静默处理了如果想要看异常信息可在协程中添加try cash 查看 2.为什么在该代码中要写入join呢，如果不写这句话不会输出GlobalScope里的内容因为GlobalScope有自己的作用域

CPU密集型任务取消

isActive是一个可以被使用在CoroutineScope中的扩展属性，检查Job是否处于活跃状态。
ensureActive()，如果job处于非活跃状态，这个方法会立即抛出异常
yield函数会检查所在协程的状态，如果已经取消，则抛出CancellationException予以相应。此外，它还会尝试出让线程的执行权，给其他协程提供执行机会

fun testCancelCPUTaskByIsActive()= runBlocking {
    val startTime = System.currentTimeMillis()
    val job = launch(Dispatchers.Default) {
        var i = 0
        var nexPrintTime = startTime
        while(i<5 && isActive){
             // ensureActive()
             // yield()
            if(System.currentTimeMillis() >= nexPrintTime){
                println("job : I'm sleeping ${i++}...")
                nexPrintTime+=1000
            }
        }
    }
    delay(500)
    println("main: I'm tired of waiting!")
    job.cancel()
    println("Main: Now I can quit.")
}

看以上代码

如果while条件中不添加 isActive 判断的话，执行job.cancel()后仍会继续执行while循环，协程会进行一些保护，因为直接取消的话一些临时计算数据会被消失，所以添加判断isActive，cancel后直接退出
利用ensureActive()，内部实现其实还是使用了isActive，如果不是活跃状态直接回抛出异常 CancellationException
yield() 出让执行权，为了防止自己抢占了全部资源，每次调用之前问一下其他是否需要执行

协程取消的副作用

在finally中释放资源
use函数：该函数只能被实现了Closeable的对象使用，程序结束后会自动调用close方法，适合文件对象

fun testReleaseResources()= runBlocking {
    val job = launch {
        try {
            repeat(1000){ index->
                println("job : I'm sleeping $index...")
                delay(500)
            }
        } finally {
            println("job: I'm running finally")
        }
    }
    delay(1300)
    println("main: I'm tired of waiting!")
    job.cancelAndJoin()
    println("Main: Now I can quit.")
}

fun testUseFunction() = runBlocking {
    val br = BufferedReader(FileReader("build.gradle.kts"))
    br.use {
        var line : String?
        while(true){
            line =  it.readLine() ?: break
            println(line)
        }
    }
}

不能取消的任务

处于取消中状态的协程不能挂起（运行不能取消的代码），当协程被取消后需要调用挂起函数，我们需要将清理任务的代码放置于NonCancellable CoroutineContext中
这样会挂起运行中的代码，并保持协程的取消中状态直到任务处理完成

fun testReleaseResources()= runBlocking {
    val job = launch {
        try {
            repeat(1000){ index->
                println("job : I'm sleeping $index...")
                delay(500)
            }
        } finally {
            println("job: I'm running finally")
        }
    }
    delay(1300)
    println("main: I'm tired of waiting!")
    job.cancelAndJoin()
    println("Main: Now I can quit.")
}

以上代码中，协程进入取消状态，假设在finally里调用 delay(1000)挂起函数，不会执行的，这时候我们需要用到NonCancellable

finally {
   withContext(NonCancellable){
       println("job: I'm running finally")
       delay(1000)
       println("job: And I've just delayed for 1 sec because I'm non-cancellable")
   }
}

超时任务

很多情况下取消协程的理由是它有可能超时
withTimeoutOrNull 通过返回null来进行超时操作，从而替代抛出一个异常

fun testDealWithTimeout() = runBlocking {
    val result = withTimeoutOrNull(1300){
        repeat(1000){ index->
            println("job : I'm sleeping $index...")
            delay(500)
        }
        "Done"
    }
    println("Result is $result") // 如果执行完了会打印Done 如果没有会打印 null
}