Kotlin学习 9 -- 协程

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

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，从而让代码更简洁。

本篇文章就介绍到这。

©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 219,869评论 6赞 508
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 93,716评论 3赞 396
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 166,223评论 0赞 357
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 59,047评论 1赞 295
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 68,089评论 6赞 395
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 51,839评论 1赞 308
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 40,516评论 3赞 420
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 39,410评论 0赞 276
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 45,920评论 1赞 319
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 38,052评论 3赞 340
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 40,179评论 1赞 352
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 35,868评论 5赞 346
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 41,522评论 3赞 331
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 32,070评论 0赞 22
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 33,186评论 1赞 272
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 48,487评论 3赞 375
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 45,162评论 2赞 356