程序员最近都爱上了这个网站  程序员们快来瞅瞅吧！  it98k网:it98k.com

前言

在上一篇中，对Kotlin协程对应取消组合挂起函数进行了初步的认识。在这篇中，将会讲解Kotlin协程对应的释放资源、超时、组合挂起函数相关知识点！

话不多说，直接开始！

先看上一篇的例子：

fun main() = runBlocking<Unit> {
    val job = launch {
        repeat(1000){ i ->
            println("job:I'm sleeping $i")
            delay(10L)
            //分析点1 ，如果说在这释放资源？？会有什么后果？？
        }
    }
    delay(130L)
    println("main: I'm tired of waiting!")
    job.cancelAndJoin()
    println("main:Now I can quit!")
}

运行效果

job:I'm sleeping 0
job:I'm sleeping 1
...略
job:I'm sleeping 10
main: I'm tired of waiting!
main:Now I can quit!

首先我们通过repeat(1000)是想让闭包内部的代码循环1000次，但是主线程因为调用job.cancelAndJoin()而强制终止了内部循环。

试想一下，我们在请求网络连接网络的时候，以及读取文件流的时候，都是通过耗时操作都是在线程里面执行的。

如果说，像这样通过job.cancelAndJoin()，造成没有执行完或者说对应的流没有正常释放关闭时，将会造成大量的内存泄露。（也就是分析点1位置）

因此，Kotlin给我们对应的解决方案：

1、在 finally 中释放资源

刚刚的代码因此被改造成：

fun main() = runBlocking {
    val job = launch {
        try {
            repeat(1000) { i ->
                println("job:I'm sleeping $i ...")
                delay(10L)
                //就不在这里释放资源
            }
        } finally {
            //在这里释放资源
            // 任何尝试在 finally 块中调⽤挂起函数的⾏为都会抛出 CancellationException
            // 因为这⾥ 持续运⾏的代码是可以被取消的
            println("job:I'm running finally")
        }
    }
    delay(130L)
    println("main:I'm tired of waiting!")
    job.cancelAndJoin()
    println("main:Now I can quit.")
}

在这里加了一个finally{}，先来看看运行效果：

job:I'm sleeping 0 ...
job:I'm sleeping 1 ...
...略
job:I'm sleeping 10 ...
main:I'm tired of waiting!
job:I'm running finally
main:Now I can quit.

注意看这个运行效果：

• 先是运行的是：main:I'm tired of waiting!，随后job:I'm running finally；
• 也就是说，当主线程执行job.cancelAndJoin()将会一直等待协程里面的finally{}运行完后才会继续往下执行！
• 因此不管对应的协程是否正常完成，都会先执行这代码块，随后才是真正的完成，所以可以将释放资源部分放在finally{}这里

然而，在真实释放资源过程中，往往需要一个被取消的协程，那试试在finally{}里调用挂起函数呢？

fun main() = runBlocking {
    val job = launch {
        try {
            repeat(1000) { i ->
                println("job:I'm sleeping $i ...")
                delay(10L)
            }
        } finally {
            delay(20L)
            println("job:I'm running finally")
        }
    }
    delay(130L)
    println("main:I'm tired of waiting!")
    job.cancelAndJoin()
    println("main:Now I can quit.")
}

代码没有报任何错！运行看看效果：

...略
job:I'm sleeping 9 ...
job:I'm sleeping 10 ...
main:I'm tired of waiting!
main:Now I can quit.

注意看最后几行！我的job:I'm running finally释放资源并没有执行！

这个时候就需要新的东西了！ withContext(NonCancellable){}

1.1 withContext(NonCancellable){}

我们先来看看这个代码块具体是什么意思！

如图所示

总结下就一句话：当执行取消时，对应 withContext 内的代码块不会随着取消而取消，还是会执行对应代码块的内容。更重要的是不会影响原有协程的逻辑！

所以再次改造代码：

fun main() = runBlocking {
    val job = launch {
        try {
            repeat(1000) { i ->
                println("job:I'm sleeping $i ...")
                delay(10)
            }
        } finally {
            withContext(NonCancellable){
                println("job:I'm running finally")
                delay(20L)
                println("可以在这释放对应的资源了")
            }
        }
    }
    delay(130L)
    println("main:I'm tired of waiting!")
    job.cancelAndJoin()
    println("main:Now I can quit.")
}

运行效果

job:I'm sleeping 0 ...
job:I'm sleeping 1 ...
...略
job:I'm sleeping 10 ...
job:I'm sleeping 11 ...
main:I'm tired of waiting!
job:I'm running finally
可以在这释放对应的资源了
main:Now I can quit.

当我们执行取消或者请求网络耗时操作时，往往可能会面对超时的情况，那么超时该如何处理呢？

2、超时处理

2.1 withTimeout

fun main() = runBlocking {
    withTimeout(1330L){
        repeat(1000){ i ->
            println("I'm sleeping $i")
            delay(500L)
        }
    }
}

从这个代码块看出：在1330L毫秒里循环了1000次，每一次都挂起了500毫秒！

运行效果

I'm sleeping 0
I'm sleeping 1
I'm sleeping 2
Exception in thread "main" kotlinx.coroutines.TimeoutCancellationException: Timed out waiting for 1330 ms

我们发现，当超过1330L毫秒时，就直接崩溃了！在实际使用中肯定不允许程序奔溃，所以有withTimeoutOrNull来替代超时操作！

2.2 withTimeoutOrNull

fun main() = runBlocking {

    //withTimeoutOrNull 通过返回 null 来进⾏超时操作，从⽽替代抛出⼀个异常：
    val result = withTimeoutOrNull(1330L){
        repeat(1000){ i ->
            println("I'm sleeping $i")
            delay(500L)
        }
        "OK" //当返回OK时，表示上面的循环执行完了，否则就为NULL
    }
    println(result ?: "Done")
}

这里我们看到使用了withTimeoutOrNull来代替withTimeout，从方法上看，好像超时的话就为Null！

来看看运行效果：

I'm sleeping 0
I'm sleeping 1
I'm sleeping 2
Done

这没有好多可说的，很简单！下一个！

现在讲了释放资源，以及超时。模拟一个实战看看！

3、模拟实战

我们就模拟一个瀑布流加载本地图片文件操作

3.1 没有加finally{}

import kotlinx.coroutines.*

var acquired = 0
class Resource {
    init {
        acquired++
    }
    fun close() {
        acquired--
    }
}
fun main() {
    runBlocking {
        repeat(1000){
            launch {
                val resource = withTimeout(60){ //设置60毫秒加载时间
                    delay(30)  //这里可以随意改 只有不超过60 ，不让它超时就行
                    Resource() 
                }
                //使用完了关闭对应资源
                resource.close()
            }
        }
    }
    //非0，有内存泄漏
    //0代表资源都释放了，没有内存泄漏
    println(acquired) //期待值是0
}

这里我们看到，一开始创建了模拟资源文件，每次使用全局自增一，每次关闭全局自减一。

如果说最后打印为0，则说明资源全部释放完毕，否则就会出现内存泄露！

注意：这里我故意没有用finally，来看看没有用finally是什么样子！

运行效果

51  //每次运行都还不一样！如果每次都为0的话，可以改上面备注的那个挂起时间！

那加上finally试试！

3.2 加上finally{}

import kotlinx.coroutines.*

var acquired = 0

//伪代码
class Resource {
    init {
//        println("init $acquired")
        acquired++
    }

    fun close() {
//        println("close $acquired")
        acquired--
    }
}

fun main() {
    runBlocking {
        repeat(1000) {
            launch {
                var resource: Resource? = null
                try {
                    withTimeout(60) {
                        delay(30)
                        resource = Resource()
                    }
                } finally {
                    resource?.close()
                }
            }
        }

    }
    //0代表资源都释放了，没有内存泄漏
    println(acquired) //期待值是0
}

这里我们看到，在try上面定义了可空变量，每次实例化资源的时候就赋值，在finally里面如果不为空就关闭资源。

运行效果

0

所有资源完美释放完毕，当然读者可以将上面的注释打开再次运行下，看是否执行过对应的方法。

4、组合挂起函数

在上一篇中，讲解了何为挂起函数！那么现在来看看组合挂起函数怎么使用的！

4.1 默认使用

suspend fun doSomethingUsefulOne(): Int {
    println("doSomethingUsefulOne")
    //所有kotlinx.coroutines中的挂起函数都是可被取消的。
    delay(1000L)
    return 13
}

suspend fun doSomethingUsefulTwo(): Int {
    println("doSomethingUsefulTwo")
    delay(1000L)
    return 29
}


fun main() = runBlocking {
    val time = measureTimeMillis { // 这个方法仅仅只是统计闭包里代码块总共运行的时间！
        val one = doSomethingUsefulOne()
        val two = doSomethingUsefulTwo()
        println("The answer is ${one + two}")
    }
    println("Completed in $time ms")
}

这个measureTimeMillis {}仅仅表示统计闭包里运行总时长。其余的没啥可说的！

直接看运行效果

doSomethingUsefulOne
doSomethingUsefulTwo
The answer is 42
Completed in 2070 ms

可以看到这两个方法都是按照顺序执行的！上面执行完了才执行下一个！

那如果说，想要这两个一起执行（同步执行）该怎样呢？

4.2 同步执行

suspend fun doSomethingUsefulOne(): Int {
    println("doSomethingUsefulOne")
    //所有kotlinx.coroutines中的挂起函数都是可被取消的。
    delay(1000L)
    return 13
}

suspend fun doSomethingUsefulTwo(): Int {
    println("doSomethingUsefulTwo")
    delay(1000L)
    return 29
}

//使⽤ async 并发
fun main() = runBlocking {
    val time = measureTimeMillis {
        val one = async { doSomethingUsefulOne() }
        val two = async { doSomethingUsefulTwo() }
        println("The answer is ${one.await() + two.await()}")
    }
    //这⾥快了两倍，因为两个协程并发执⾏。请注意，使⽤协程进⾏并发总是显式的。
    println("Completed in $time ms")
}

现在发现在调用每个挂起函数时，额外加了async {}闭包，使用时额外多了.await()方法。

来看看运行效果：

doSomethingUsefulOne
doSomethingUsefulTwo
The answer is 42
Completed in 1073 ms

从这个运行效果来看，可以发现这俩方法是同步执行的！

那如果说，不想让它这么快执行，我想先初始化好，等我想执行的时候再来执行它！

Koltin也给我们安排上了！

4.3 惰性执行

suspend fun doSomethingUsefulOne(): Int {
    println("doSomethingUsefulOne")
    //所有kotlinx.coroutines中的挂起函数都是可被取消的。
    delay(1000L)
    return 13
}

suspend fun doSomethingUsefulTwo(): Int {
    println("doSomethingUsefulTwo")
    delay(1000L)
    return 29
}

fun main() = runBlocking {
    val time = measureTimeMillis {
        val one = async(start = CoroutineStart.LAZY) { doSomethingUsefulOne() }
        val two = async(start = CoroutineStart.LAZY) { doSomethingUsefulTwo() }
        
        //执行two之前，这里随意添加任何逻辑判断

        two.start()
        
        //执行one之前，这里随意添加任何逻辑判断
        //two.join() 加上这句话的意思就是，等待two执行完毕时，才调用下面的代码
        one.start()
        println("The answer is ${one.await() + two.await()}")
    }
    println("Completed in $time ms")
}

这里我们看到，在async后面额外增加了(start = CoroutineStart.LAZY)代码块，表示对应的挂起函数为惰性函数，需要后面手动调用对应的.start()才会执行对应的挂起函数。

这里我故意将two放在one之前！

来看看运行效果

doSomethingUsefulTwo
doSomethingUsefulOne
The answer is 42
Completed in 1098 ms

因为这在两个挂起函数启动之间没有加任何逻辑代码，所以运行时间和同步差不多。但可以看出，已经可以通过代码来控制对应挂起函数的执行顺序！达到了惰性执行的效果！

结束语

好了，本篇到这里就结束了！相信你对Kotlin有了更深一步的认知！在下一篇中，将会开启对Kotlin协程上下文与调度器的讲解！