Kotlin学习笔记之 31 协程挂起函数的组合

首发于公众号: DSGtalk1989

31.协程挂起函数的组合

• 同步与并发

  通常情况下，协程中的挂起函数都是同步执行的，执行完一个执行另一个，我们举个例子，作如下的两种计算。

  suspend fun doSomethingUsefulOne(): Int {
        delay(1000L) // 假设我们在这里做了某些有用的工作
        return 13
    }
    
    suspend fun doSomethingUsefulTwo(): Int {
        delay(1000L) // 假设我们在这里也做了某些有用的工作
        return 29
    }
    
    fun main() = runBlocking {
    //sampleStart
        val time = measureTimeMillis {
            val one = doSomethingUsefulOne()
            val two = doSomethingUsefulTwo()
            println("The answer is ${one + two}")
        }
        println("Completed in $time ms")
    //sampleEnd    
    }
  

  这里出现了一个measureTimeMillis方法，这个方法会返回一个long，表示这个协程的消耗时间。最终打印是这样的。

  The answer is 42
  Completed in 2017 ms
  

  这时候，如果我们希望两个任务是并发的，需要使用到async。

  我们写一个async{}，然后点进去看一下。

  public fun  CoroutineScope.async(
    context: CoroutineContext = EmptyCoroutineContext,
    start: CoroutineStart = CoroutineStart.DEFAULT,
    block: suspend CoroutineScope.() -> T
  

): Deferred

跟之前展示的`launch`除了一个返回的是`Job`一个返回的是`Deferred`，其他是一模一样。进去一看

```js
/**
* Deferred value is a non-blocking cancellable future — it is a [Job] that has a result
*/
public interface Deferred : Job

是一个实现了Job的接口，注释中说到是一个不会阻塞的，可以被取消的future，是一个有结果的Job。看上去可以在未来的某个时间点执行，而非立马执行的，且是异步的。

在Job的基础上多了3个方法和一个属性。

public suspend fun await(): T
public val onAwait: SelectClause1
public fun getCompleted(): T
public fun getCompletionExceptionOrNull(): Throwable?

下面两个都是实验性质的，我们就不看了主要是为了去拿异步协程的结果的。而现在本身可以直接通过await也可以拿到结果。并且不会将协程再跑一遍。

我们对上面的部分代码略做改动，其他保持不变。

val one = async { doSomethingUsefulOne() }
val two = async { doSomethingUsefulTwo() }
println("The answer is ${one.await() + two.await()}")

打印出来的结果是

The answer is 42
Completed in 1017 ms

很明显的两个挂起的函数变成了异步。

如果我们希望只有调用了await方法才会开始启动协程，而不是在定义的时候就立马启动，可以针对async方法传入start参数CoroutineStart.LAZY。

val one = async(start = CoroutineStart.LAZY) { doSomethingUsefulOne() }
  val two = async(start = CoroutineStart.LAZY) { doSomethingUsefulTwo() }
  // 执行某些计算
  one.start() // 启动第一个协程
  two.start() // 启动第二个协程
  println("The answer is ${one.await() + two.await()}")

这样一来只会在调用了start或者await方法之后，整个协程才会启动。

• 作用域异常

  一旦作用域中抛出了异常，一般情况下都会直接导致所有兄弟协程中断，以及等待的父协程中断。

  但是使用全局作用域的协程并不会有中断问题，即使其中一个子协程抛出异常，其他的照跑不误。

  suspend fun failedConcurrentSum(): Int = coroutineScope {
        val one = async {
            try {
                delay(Long.MAX_VALUE) // 模拟一个长时间的计算过程
                42
            } finally {
                println("First child was cancelled")
            }
        }
        val two = async {
            println("Second child throws an exception")
            throw ArithmeticException()
        }
            one.await() + two.await()
    }
  

  打印出

  Second child throws an exception
  First child was cancelled
  

---

Kotlin学习笔记之 1 基础语法

Kotlin学习笔记之 2 基本数据类型

Kotlin学习笔记之 3 条件控制

Kotlin学习笔记之 4 循环控制

Kotlin学习笔记之 5 类和对象

Kotlin学习笔记之 6 继承

Kotlin学习笔记之 7 接口

Kotlin学习笔记之 8 扩展

Kotlin学习笔记之 9 数据类与密封类

Kotlin学习笔记之 10 泛型

Kotlin学习笔记之 11 枚举类

Kotlin学习笔记之 12 对象表达式和对象声明

Kotlin学习笔记之 13 基础操作符run、with、let、also、apply

Kotlin学习笔记之 14 包与导入

Kotlin学习笔记之 15 伴生对象

Kotlin学习笔记之 16 委托

Kotlin学习笔记之 17 可观察属性

Kotlin学习笔记之 18 函数

Kotlin学习笔记之 19 高阶函数与 lambda 表达式

Kotlin学习笔记之 20 内联函数

Kotlin学习笔记之 21 解构声明

Kotlin学习笔记之 22 集合

Kotlin学习笔记之 23 相等判断

Kotlin学习笔记之 24 操作符重载

Kotlin学习笔记之 25 异常捕捉

Kotlin学习笔记之 26 反射

Kotlin学习笔记之 27 类型别名

Kotlin学习笔记之 28 协程基础

Kotlin学习笔记之 29 上下文与调度器

Kotlin学习笔记之 30 协程取消与超时

Kotlin学习笔记之 31 协程挂起函数的组合

Kotlin学习笔记之 32 协程异常处理

Kotlin学习笔记之 33 协程 & Retrofit