Kotlin学习 9 -- 协程

2020-08-05 本文已影响0人开心wonderful

本篇文章主要介绍以下几个知识点：

协程的基本用法

作用域构造器

使用协程简化回调写法
内容参考自第一行代码第3版

SUMMER DAY (图片来源于网络)

1. 协程的基本用法

协程可以简单看作是一种轻量级的线程。一般线程需要依赖操作系统的调度才能实现不同线程之间的切换，而协程却可以在编程语言层面实现不同协程之间的切换，大大提升了并发编程的运行效率。

使用协程需要添加如下依赖：

implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.3.0"
implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.3.0"

1.1 GlobalScope.launch 函数与 runBlocking 函数

开启一个协程最简单的方式是用 GlobalScope.launch 函数，如下：

fun main() {
    // GlobalScope.launch 函数可创建一个协程作用域，里面的代码块就是在协程中运行了
    GlobalScope.launch {
        println("code run in coroutine scope")
    }
}

当然，上面运行 main() 函数并不能打印出日志，因为 GlobalScope.launch 函数每次创建都是一个顶层协程，这种协程当程序运行结束时也会跟着一起结束，使得应用程序结束了而上面代码块中的代码还没来得及运行。

解决这个问题很简单，让程序延迟一段时间在结束运行即可：

fun main() {
    // GlobalScope.launch 函数可创建一个协程作用域，里面的代码块就是在协程中运行了
    GlobalScope.launch {
        println("code run in coroutine scope")
    }
    Thread.sleep(1000)
}

上面代码运行可以正常打印日志了，但若代码块中的代码不能在延迟一段时间内运行结束，那么还是会存在问题：

fun main() {
    GlobalScope.launch {
        println("code run in coroutine scope")
        // delay() 是一个非阻塞式挂起函数，它只会挂起当前协程，不影响其他协程运行
        // delay() 只能在协程的作用域或其他挂起函数中调用
        // 这边让协程挂起1.5秒
        delay(1500) 
        println("code run in coroutine scope finished")
    }
    // 和 delay() 函数不同，Thread.sleep() 会阻塞当前的线程，运行在该线程下的所有协程都会被阻塞
    Thread.sleep(1000)
}

上面运行会发现第二条日志没打印出来，原因还是因为它还没来得及运行应用程序就结束了。

当然，此时可以借助 runBlocking 函数了，它同样会创建一个协程作用域，但它可以保证在协程作用域内的所有代码和子协程全部执行完之前一直阻塞当前线程：

fun main() {
    runBlocking {
        println("code run in coroutine scope")
        delay(1500)
        println("code run in coroutine scope finished")
    }
}

这样，两条日志都可以正常打印出来了。

注：runBlocking 函数通常只在测试环境下使用，在正式环境中使用容易产生一些性能上的问题。

1.2 launch 函数

当涉及到高并发的应用场景时，就能体现出协程相比线程的优势，创建多个协程可以使用 launch 函数：

fun main() {
    runBlocking { 
        // launch 函数必须在协程的作用域才能调用，它会在当前作用域下创建子协程
        // 若外层作用域的协程结束了，该作用域下的所有子协程也会一同结束
        launch { 
            println("launch1")
            delay(1000)
            println("launch1 finished")
        }
        launch {
            println("launch2")
            delay(1000)
            println("launch2 finished")
        }
    }
}
// 打印结果：launch1，launch2，launch1 finished，launch2 finished

上面两个子协程的日志是交替打印的，即并发运行的，不过它们运行在同一个线程中，只是由编程语言来决定如何在多个协程之间进行调度，使得协程的并发效率很高。

1.3 suspend 关键字与 coroutineScope 函数

在 launch 函数中编写的代码是拥有协程作用域的，若将部分代码提取到一个单独的函数中就没有协程作用域了，从而无法调用像 delay() 这样的挂起函数，此时就需要借助 suspend 关键字。

关键字 suspend 可以将任意函数声明成挂起函数，挂起函数之间可以相互调用，使用如下：

// suspend 关键字只能将一个函数声明成挂起函数，是无法给它提供协程作用域的
// 由于 launch 函数必须在协程作用域才能调用，因而在这里此时是无法调用 launch 函数的
suspend fun printDot() {
    println(".")
    delay(1000)
}

上面要在 printDot() 中调用 launch 函数，还需要借助 coroutineScope 函数。

函数 coroutineScope 是一个挂起函数，从而可以在其他挂起函数中调用，它会继承外部的协程作用域并创建一个子作用域，写法如下：

suspend fun printDot() = coroutineScope {
    launch {
        println(".")
        delay(1000)
    }
}

另外，coroutineScope 函数和 runBlocking 函数有点类似，可以保证其作用域内的所有代码和子协程在全部执行完之前，会一直阻塞当前协程。

小结1：coroutineScope 函数只会阻塞当前协程，不影响其他协程和线程，从而不会有性能上的问题；runBlocking 函数会阻塞当前线程，若在主线程中调用它的话，可能会导致界面卡死的现象，不推荐在实际项目中使用。

小结2： GlobalScope.launch 和 runBlocking函数可以在任意地方调用，coroutineScope 函数可以在协程作用域或挂起函数中调用，而 launch 函数只能在协程作用域中调用。

小结3： GlobalScope.launch 每次创建的都是顶层协程，一般也不太建议使用，除非明确要创建顶层协程。

2. 作用域构建器

前面学习的 GlobalScope.launch、runBlocking、launch、coroutineScope 几种作用域构建器，都可以用于创建一个新的协程作用域。

2.1 取消协程

不管是 GlobalScope.launch 还是 launch 函数，都会返回一个 Job 对象，调用其 cancel() 方法可取消协程，如下：

val job = GlobalScope.launch { 
    // to do something
}
job.cancel()

若在 Acitivity 使用 GlobalScope.launch 这种协程作用域构建器，每次创建的都是顶层协程，那么当 Activity 关闭时，此时需要取消协程，就需要逐个调用所有已创建协程的 cancel() 方法，使得代码不好维护，因而在实际项目中不太常用这种协程作用域构建器，比较常用的写法如下：

// 创建 Job 对象
val job = Job()
// 传入 CoroutineScope 函数
val scope = CoroutineScope(job)
scope.launch { 
    // to do something
}
job.cancel()

这样，所有调用 CoroutineScope 的 launch 函数创建的协程都会被关联到 Job 对象的作用域下，只需调用一次 cancel() 方法，就可把同一作用域内的所有协程取消，大大降低了协程管理成本。

2.2 async 函数

调用 launch 函数可以创建一个新的协程，但它只能用于执行一段逻辑，返回一个 Job 对象，不能获取执行结果，要获取执行结果可以借助 async 函数。

async 函数必须在协程作用域中才能调用，它会创建一个新的子协程并返回一个 Deferred 对象，调用 Deferred 对象的 await() 方法可获取执行结果，如下：

fun main() {
    runBlocking {
        val result = async {
            10 + 10
        }.await()
        println(result)
    }
}
// 打印结果：20

当调用 await() 方法时，若代码块中的代码还没执行完，await() 方法就会将当前协程阻塞，直到可以获得 async 函数的执行结果。

举个栗子，用两个 async 函数来执行延迟任务，并记录运行耗时，如下：

fun main() {
    runBlocking {
        val start = System.currentTimeMillis()
        val result1 = async {
            delay(1000)
            10 + 10
        }.await()
        val result2 = async {
            delay(1000)
            15 + 5
        }.await()
        println("result is ${result1 + result2}")
        val end = System.currentTimeMillis()
        println("cost time is ${end - start} ms")
    }
}
// 打印结果：result is 40，cost time is 2069 ms

由于上面两个 async 函数是一种串行的关系，前一个执行完后一个才执行，因而这种写法非常低效，修改代码使得两个 async 函数同时执行如下：

fun main() {
    runBlocking {
        val start = System.currentTimeMillis()
        val deferred1 = async {
            delay(1000)
            10 + 10
        }
        val deferred2 = async {
            delay(1000)
            15 + 5
        }
        println("result is ${deferred1.await() + deferred2.await()}")
        val end = System.currentTimeMillis()
        println("cost time is ${end - start} ms")
    }
}
// 打印结果：result is 40，cost time is 1043 ms

上面在需要用到 async 函数的执行结果时才调用 await() 方法进行获取，此时就变成一种并行关系了，运行效率也就提升了。

2.3 withContext 函数

withContext() 函数 是一个比较特殊的作用域构建器，它是一个挂起函数，可以理解成 async 函数的一种简化版写法，用法如下：

fun main() {
    runBlocking {
        // 调用 withContext() 函数后，会立即执行代码块中的代码，同时把当前协程阻塞
        // 当代码块中的代码执行完后会吧最后一行的执行结果作为返回值返回
        // 相当于 val result = async{10 + 10}.await() 的写法
        val result = withContext(Dispatchers.Default) {
            10 + 10
        }
        println(result)
    }
}

值得注意的是，withContext() 函数强制要求指定一个线程参数，线程参数有以下3种：

Dispatchers.Default 使用一种默认低并发的线程策略
Dispatchers.IO 使用一种较高并发的线程策略，如网络请求
Dispatchers.Main 不会开启子线程，在主线程中执行，只能在Android项目中用

注：在协程作用域构建器中，所有的函数都可以指定一个线程参数，只不过 withContext() 函数是强制要求指定的，其他函数则是可选的。

3. 使用协程简化回调的写法

平时网络请求数据时会采用回调机制来处理，回调机制基本上是靠匿名类来实现的：

val address = "https://www.baidu.com/"
// 模拟一个网络请求回调
HttpUtil.sendHttpRequest(address, object :HttpCallbackListener{
    override fun onFinish(response: String) {
        // 得到服务器返回内容
    }

    override fun onError(e: Exception) {
        // 对异常处理
    }
})

在 Kotlin 中，可以通过 suspendCoroutine 函数把传统的回调机制的写法大幅简化。

suspendCoroutine 函数必须在协程作用域或挂起函数中调用，它接收一个 Lambda 表达式参数，将当前协程立即挂起，然后在一个普通的线程中执行 Lambda 表达式中的代码。

上述 Lambda 参数列表上会传入一个 Continuation 参数，调用它的 resume() 方法或 resumeWithException() 可以让协程恢复执行。

定义个 request() 函数优化上面的的回调写法如下：

suspend fun request(address: String): String {
    return suspendCoroutine { continuation ->
        HttpUtil.sendHttpRequest(address, object : HttpCallbackListener {
            override fun onFinish(response: String) {
                // 成功
                continuation.resume(response)
            }

            override fun onError(e: Exception) {
                // 失败
                continuation.resumeWithException(e)
            }
        })
    }
}

调用时就可以这样写：

suspend fun getBaiduResponse() {
    try {
        val response = request("https://www.baidu.com/")
        // 进行数据处理
    } catch (e: Exception) {
        // 异常处理
    }
}

这样，代码就清爽了许多。

再举个栗子，平时使用 Retrofit 来发起网络请求时先定义接口和创建构建器：

// Retrofit 构建器
object ServiceCreator {
    private const val BASE_URL = "..."

    private val retrofit =
        Retrofit.Builder().baseUrl(BASE_URL).addConverterFactory(GsonConverterFactory.create())
            .build()

    // 获取 Service 接口的动态代理对象方法
    // 使用：val appService = ServiceCreator.create(AppService::class.java)
    fun <T> create(serviceClass: Class<T>): T = retrofit.create(serviceClass)

    // 通过泛型实化进一步优化：获取 Service 接口的动态代理对象方法
    // 使用：val appService = ServiceCreator.create<AppService>()
    inline fun <reified T> create(): T = create(T::class.java)
}

// 定义接口
interface ApiService {
    @GET("xxx/xxx")
    fun getAppData(): Call<List<String>>
}

接着发起网络请求：

val appService = ServiceCreator.create<ApiService>()
appService.getAppData().enqueue(object : Callback<List<String>> {
    override fun onFailure(call: Call<List<String>>, t: Throwable) {
        // 失败逻辑处理
    }

    override fun onResponse(call: Call<List<String>>, response: Response<List<String>>) {
        // 成功逻辑处理
    }
})

这时，使用 suspendCoroutine 函数可以对上面写法进行优化。使用泛型的方式定义一个 await() 函数如下：

// 这里 await() 定义成一个挂起函数，并定义成 Call<T> 的扩展函数，
// 从而所有返回值是 Call 类型的 Retrofit 网络请求接口都可以直接调用 await() 函数
suspend fun <T> Call<T>.await(): T {
    return suspendCoroutine { continuation ->
        // 由于扩展函数的原因，这里拥有了 Call 对象的上下文，
        // 从而可以直接调用 enqueue() 方法让 Retrofit 发起网络请求
        enqueue(object : Callback<T> {
            override fun onFailure(call: Call<T>, t: Throwable) {
                // 失败
                continuation.resumeWithException(t)
            }

            override fun onResponse(call: Call<T>, response: Response<T>) {
                // 成功
                val body = response.body()
                if (body != null) continuation.resume(body)
                else continuation.resumeWithException(RuntimeException("body is null"))
            }
        })
    }
}

有了 await() 函数后，调用 Retrofit 的接口就会简单很多，比如上面的发起网络请求就可以写成：

suspend fun getAppData(){
    try {
        // 只需简单调用 await() 函数即可获取响应数据
        val result = ServiceCreator.create<ApiService>().getAppData().await()
        // 成功逻辑处理
    } catch (e: Exception){
        // 异常逻辑处理
    }
}

注：每次发起请求时都进行 try catch 处理比较麻烦，可以选择不处理。在不处理情况下，若发生异常就会一层层向上抛出，直到某一层的函数处理为止。也可以在某个统一的入口函数中只进行一次 try catch，从而让代码更简洁。

本篇文章就介绍到这。