Kotlin中协程封装与取消

1. 将java中的回调接口封装成挂起函数

  • 以OKHttp请求为例,代码如下 :
import okhttp3.Call
import okhttp3.Callback
import okhttp3.Response
import java.io.IOException
import kotlin.coroutines.resume
import kotlin.coroutines.resumeWithException
import kotlin.coroutines.suspendCoroutine

suspend fun Call.await(): String = suspendCoroutine { block ->
    enqueue(object : Callback {
        override fun onFailure(call: Call, e: IOException) {
            block.resumeWithException(e)
        }

        override fun onResponse(call: Call, response: Response) {
            if (response.isSuccessful) {
                block.resume(response.body()!!.string())
            }
        }
    })
}

  • 挂起函数的使用如下:
val client: OkHttpClient = OkHttpClient.Builder() .build()
        val request: Request = Request.Builder()
            .get()
            .url("http://xxx")
            .build()
  GlobalScope.async(Dispatchers.Main) {
            val call = client.newCall(request)
            val data = call.await()
        }

因为Call的扩展函数await()是个挂起函数,所以必须运行在协程或者其他的挂起函数中

  • 对OkHttp的Call类继续扩展,添加一个await()函数,函数的返回值为 String类型,在函数中使用挂起函数suspendCoroutine{}或suspendCancellableCoroutine{},await()函数调用时,首先会挂起当前协程,然后执行enqueue将网络请求放入队列中,当请求成功时,通过block.resume(response.body()!!.string())来恢复之前的协程。

  • suspendCancellableCoroutine{}函数实现功能的函数:

delay()函数

yield()函数:挂起当前协程,然后将协程分发到 Dispatcher 的队列,这样可以让该协程所在线程或线程池可以运行其他协程逻辑,然后在 Dispatcher 空闲的时候继续执行原来协程。简单的来说就是让出自己的执行权,给其他协程使用,当其他协程执行完成或也让出执行权时,一开始的协程可以恢复继续运行

2. 父子协程

  • GlobalScope.launch()函数和GlobalScope.async()函数是没有父协程的被称为全局协程。

  • 当一个协程被其它协程在 CoroutineScope 中启动的时候, 它将通过 CoroutineScope.coroutineContext 来承袭上下文,并且这个新协程的 Job 将会成为父协程任务的子任务。当一个父协程被取消的时候,所有它的子协程也会被递归的取消。例子如下:

GlobalScope.launch(Dispatchers.Main) {
            //父协程
            launch { 
                //子协程
            }
            async {
                //子协程 
            }
            withContext(coroutineContext){
                //子协程
            }
        }
  • 协程间父子关系有三种影响:

    • 父协程手动调用cancel()或者异常结束,会立即取消它的所有子协程。

    • 父协程必须等待所有子协程完成(处于完成或者取消状态)才能完成。

    • 子协程抛出未捕获的异常时,默认情况下会取消其父协程。

3. 协程取消

  • 实例1:
fun main() = runBlocking {
    val job = launch {
        launch {
            repeat(6) {
                println("run_child:$it")
                delay(500)
            }
        }
        repeat(6) {
            println("run_parent:$it")
            delay(500)
        }
    }
    delay(1600)
    job.cancel()
    println("job end")

}
  • 结果

  • 上面代码中 job 取消后,delay()会检测协程是否已取消,所以 job.cancel()调用之后上面的父协程和子协程也都会取消

  • 实例2:

fun main() = runBlocking {
    val job = launch(Dispatchers.Default) {
        var nextTime = 0L
        var i = 1
        while (i <= 3) {
            val nowTime = System.currentTimeMillis()
            if (nowTime >= nextTime) {
                println("parent_${i++}")
                nextTime = nowTime + 500L
            }
        }
    }
    delay(800)
    job.cancel()
    println("job end")
}
  • 结果

  • 上面代码中 job 取消后,没有检测协程状态的逻辑,都是计算逻辑,所以 job 的运算逻辑还是会继续运行。

  • 为了可以及时取消协程的运算逻辑,可以检测协程的状态,使用isActive来判断,上面示例中可以将while(i <= 3)替换为while(isActive)。代码如下:

fun main() = runBlocking {
    val job = launch(Dispatchers.Default) {
        var nextTime = 0L
        var i = 1
        while (isActive) {
            val nowTime = System.currentTimeMillis()
            if (nowTime >= nextTime) {
                println("parent_${i++}")
                nextTime = nowTime + 500L
            }
        }
    }

    delay(1200)
    job.cancel()
    println("job end")

}
  • 结果

  • 运行不能取消的代码块当手动取消协程后,像delay()这样的可取消挂起函数会在检测到已取消状态时,抛出 CancellationException 异常,然后退出协程。此时可以使用try { ... } finally { ... }表达式或 T.use {}函数执行终结动作或关闭资源。但是如果在finally块中调用自定义的或系统的可取消挂起函数,都会再次抛出 CancellationException 异常。通常我们在finally块中关闭一个文件,取消一个任务或者关闭一个通信通道都是非阻塞,并且不会调用任何挂起函数。当需要挂起一个被取消的协程时,可以将代码包装在withContext(NonCancellable) { ... }中。

4.超时取消

  • 协程库中已经提供来withTimeout() { ... }挂起函数来实现在超时后自动取消协程。它会在超时后抛出TimeoutCancellationException,它是 CancellationException 的子类,它是协程结束的正常原因,不会打印堆栈跟踪信息,如果在取消后需要执行一些关闭资源的操作可以使用前面提到的try { ... } finally { ... }表达式。
try {
    withTimeout(1300L) {
        repeat(1000) { i ->
                println("I'm sleeping $i ...")
            delay(500L)
        }
    }
} finally {
    println("I'm running finally")
}
  • 还有一个withTimeoutOrNull() { ... }挂起函数在超时后返回null,而不是抛出一个异常。
val result = withTimeoutOrNull(1300L) {
    repeat(1000) { i ->
            println("I'm sleeping $i ...")
        delay(500L)
    }
    "Done" /* 在它运行得到结果之前取消它,如果循环次数x延迟时间小等于1300则返回Done,否则返回null*/
}
println("Result is $result")

你可能感兴趣的:(Kotlin中协程封装与取消)