【备忘录】Kotlin协程（三）

（15）

//挂起函数的组合

fun main() = runBlocking {

    val elementTime = measureTimeMillis {
        val value1 = intValue1()
        val value2 = intValue2()
        println("$value1 + $value2 = ${value1 + value2}")
    }

    println("total time: $elementTime")
}

private suspend fun intValue1(): Int {
    delay(2000)
    return 15
}

private suspend fun intValue2(): Int {
    delay(3000)
    return 20
}

15 + 20 = 35
total time: 5061

(16)

//使用async与await实现并发

//从概念上说，async就像是launch一样，他会开启一个单独的协程，这个协程是个轻量级的线程，
可以与其他协程并发工作。区别在于，launch会返回一个job，但是job并不会持有任何结果值，
//而async会返回一个Deferred，这是一个轻量级的非堵塞的future，它代表一个promise，
//可以在稍后提供一个结果值。

//可以通过在一个Deferred值上调用.await()方法来获取最终的返回值，Deferred也是个job，
//因此可以在需要的时候对其进行取消

fun main() = runBlocking {

    val elementTime = measureTimeMillis {

        val value1 = async { intValue1() }
        val value2 = async { intValue2() }

        val result1 = value1.await()
        val result2 = value2.await()

        println("$result1 + $result2 = ${result1 + result2}")
    }

    println("total time: $elementTime")
}

private suspend fun intValue1(): Int {
    delay(2000)
    return 15
}

private suspend fun intValue2(): Int {
    delay(3000)
    return 20
}

15 + 20 = 35
total time: 3069

(17)

/**
 * async的延迟执行
 * 我们可以通过将async方法的start参数设置为CoroutineStart.LAZY来实现协程的延迟执行。
 * 在这种情况下，协程会在两种场景下执行：调用Deferred的await方法，或是调用job的start方法。
 */

fun main() = runBlocking {

    val elementTime = measureTimeMillis {
        val value1 = async(start = CoroutineStart.LAZY) { intValue1() }
        val value2 = async(start = CoroutineStart.LAZY) { intValue2() }

        println("Hi World")

        Thread.sleep(6000)

        value1.start()
        value2.start()

        val result1 = value1.await()
        val result2 = value2.await()

        println("$result1 + $result2 = ${result1 + result2}")
    }

    println("total time: $elementTime")
}

private suspend fun intValue1(): Int {
    delay(2000)
    return 15
}

private suspend fun intValue2(): Int {
    delay(3000)
    return 20
}

Hi World
15 + 20 = 35
total time: 9042

(18)

/**
 * 异步风格的函数
 */

fun main() {
    val elementTime = measureTimeMillis {
        val value1 = intValue1Async()
        val value2 = intValue2Async()

        runBlocking {
            println("the answer is: ${value1.await() + value2.await()}")
        }
    }

    println("total time:$elementTime")
}


private suspend fun intValue1(): Int {
    delay(2000)
    return 15
}

private suspend fun intValue2(): Int {
    delay(3000)
    return 20
}

fun intValue1Async() = GlobalScope.async {
    intValue1()
}

fun intValue2Async() = GlobalScope.async {
    intValue2()
}

the answer is: 35
total time:3151

(19)

/**
 * 使用async进行结构化并发程序开发
 */

fun main() = runBlocking {

    val elementTime = measureTimeMillis {
        println("the answer is:${intSum()}")
    }
    println("total time:$elementTime")
}

private suspend fun intSum(): Int = coroutineScope {

    val value1 = async { intValue1() }
    val value2 = async { intValue2() }

    value1.await() + value2.await()
}

private suspend fun intValue1(): Int {
    delay(2000)
    return 15
}

private suspend fun intValue2(): Int {
    delay(3000)
    return 20
}

the answer is:35
total time:3279

(20)

/**
 * 关于父子协程的异常与取消问题
 * 协程的取消总是会沿着协程的层次体系向上进行传播
 */

fun main() = runBlocking<Unit> {
    try {
        failureComputation()
    } finally {
        println("Computation failed")
    }
}

private suspend fun failureComputation(): Int = coroutineScope {
    val value1 = async {
        try {
            delay(900000)
            50
        } finally {
            println("value1 was cancelled")
        }
    }

    val value2 = async<Int> {
        Thread.sleep(2000)
        println("value2 throws an Exception")

        throw Exception()
    }

    value1.await() + value2.await()
}

value2 throws an Exception
value1 was cancelled
Computation failed
Exception in thread "main" java.lang.Exception
	at com.kotlin.Coroutinesss3.HelloKotlin6Kt$failureComputation$2$value2$1.invokeSuspend(HelloKotlin6.kt:38)
	at kotlin.coroutines.jvm.internal.BaseContinuationImpl.resumeWith(ContinuationImpl.kt:33)
	at kotlinx.coroutines.DispatchedTask.run(DispatchedTask.kt:56)
	at kotlinx.coroutines.EventLoopImplBase.processNextEvent(EventLoop.common.kt:274)
	at kotlinx.coroutines.BlockingCoroutine.joinBlocking(Builders.kt:84)
	at kotlinx.coroutines.BuildersKt__BuildersKt.runBlocking(Builders.kt:59)
	at kotlinx.coroutines.BuildersKt.runBlocking(Unknown Source)
	at kotlinx.coroutines.BuildersKt__BuildersKt.runBlocking$default(Builders.kt:38)
	at kotlinx.coroutines.BuildersKt.runBlocking$default(Unknown Source)
	at com.kotlin.Coroutinesss3.HelloKotlin6Kt.main(HelloKotlin6.kt:16)
	at com.kotlin.Coroutinesss3.HelloKotlin6Kt.main(HelloKotlin6.kt)