如何正确的在 Android 上使用协程 ?

简介: 如何正确的在 Android 上使用协程 ?

前言


你还记得是哪一年的 Google IO 正式宣布 Kotlin 成为 Android 一级开发语言吗?是 Google IO 2017 。如今两年时间过去了,站在一名 Android 开发者的角度来看,Kotlin 的生态环境越来越好了,相关的开源项目和学习资料也日渐丰富,身边愿意去使用或者试用 Kotlin 的朋友也变多了。常年混迹掘金的我也能明显感觉到 Kotlin 标签下的文章慢慢变多了(其实仍然少的可怜)。今年的 Google IO 也放出了 Kotlin First 的口号,许多新的 API 和功能特性将优先提供 Kotlin 支持。所以,时至今日,实在找不到安卓开发者不学 Kotlin 的理由了。


今天想聊聊的是 Kotlin Coroutine。虽然在 Kotlin 发布之初就有了协程,但是直到 2018 年的 KotlinConf 大会上,JetBrain 发布了 Kotlin1.3RC,这才带来了稳定版的协程。即使稳定版的协程已经发布了一年之余,但是好像并没有足够多的用户,至少在我看来是这样。在我学习协程的各个阶段中,遇到问题都鲜有地方可以求助,抛到技术群基本就石沉大海了。基本只能靠一些英文文档来解决问题。


关于协程的文章我看过很多,总结一下,无非下面几类。

第一类是 Medium 上热门文章的翻译,其实我也翻译过:

在 Android 上使用协程(一):Getting The Background

在 Android 上使用协程(二):Getting started

在 Android 上使用协程(三) :Real Work


说实话,这三篇文章的确加深了我对协程的理解。

第二类就是官方文档的翻译了,我看过至少不下于五个翻译版本,还是觉得看 官网文档 比较好,如果英文看着实在吃力,可以对照着 Kotlin 中文站的翻译来阅读。


在看完官方文档的很长一段时间,我几乎只知道 GlobalScope。的确,官方文档上基本从头到尾都是在用 GlobalScope 写示例代码。所以一部分开发者,也包括我自己,在写自己的代码时也就直接 GlobalScope 了。一次偶然的机会才发现其实这样的问题是很大的。在 Android 中,一般是不建议直接使用 GlobalScope 的。那么,在 Android 中应该如何正确使用协程呢?再细分一点,如何直接在 Activity 中使用呢?如何配合 ViewModel 、LiveData 、LifeCycle 等使用呢?我会通过简单的示例代码来阐述 Android 上的协程使用,你也可以跟着动手敲一敲。


协程在 Android 上的使用


GlobalScope

在一般的应用场景下,我们都希望可以异步进行耗时任务,比如网络请求,数据处理等等。当我们离开当前页面的时候,也希望可以取消正在进行的异步任务。这两点,也正是使用协程中所需要注意的。既然不建议直接使用 GlobalScope,我们就先试验一下使用它会是什么效果。


private fun launchFromGlobalScope() {
    GlobalScope.launch(Dispatchers.Main) {
        val deferred = async(Dispatchers.IO) {
            // network request
            delay(3000)
            "Get it"
        }
        globalScope.text = deferred.await()
        Toast.makeText(applicationContext, "GlobalScope", Toast.LENGTH_SHORT).show()
    }
}
复制代码


launchFromGlobalScope() 方法中,我直接通过 GlobalScope.launch() 启动一个协程,delay(3000) 模拟网络请求,三秒后,会弹出一个 Toast 提示。使用上是没有任何问题的,可以正常的弹出 Toast 。但是当你执行这个方法之后,立即按返回键返回上一页面,仍然会弹出 Toast 。如果是实际开发中通过网络请求更新页面的话,当用户已经不在这个页面了,就根本没有必要再去请求了,只会浪费资源。GlobalScope 显然并不符合这一特性。Kotlin 文档 中其实也详细说明了,如下所示:


Global scope is used to launch top-level coroutines which are operating on the whole application lifetime and are not cancelled prematurely. Another use of the global scope is operators running in Dispatchers.Unconfined, which don’t have any job associated with them.

Application code usually should use an application-defined CoroutineScope. Using async or launch on the instance of GlobalScope is highly discouraged.


大致意思是,Global scope 通常用于启动顶级协程,这些协程在整个应用程序生命周期内运行,不会被过早地被取消。程序代码通常应该使用自定义的协程作用域。直接使用 GlobalScope 的 async 或者 launch 方法是强烈不建议的。


GlobalScope 创建的协程没有父协程,GlobalScope 通常也不与任何生命周期组件绑定。除非手动管理,否则很难满足我们实际开发中的需求。所以,GlobalScope 能不用就尽量不用。


MainScope

官方文档中提到要使用自定义的协程作用域,当然,Kotlin 已经给我们提供了合适的协程作用域 MainScope 。看一下 MainScope 的定义:

public fun MainScope(): CoroutineScope = ContextScope(SupervisorJob() + Dispatchers.Main)
复制代码


记着这个定义,在后面 ViewModel 的协程使用中也会借鉴这种写法。

给我们的 Activity 实现自己的协程作用域:

class BasicCorotineActivity : AppCompatActivity(), CoroutineScope by MainScope() {}
复制代码


通过扩展函数 launch() 可以直接在主线程中启动协程,示例代码如下:

private fun launchFromMainScope() {
    launch {
        val deferred = async(Dispatchers.IO) {
            // network request
            delay(3000)
            "Get it"
        }
        mainScope.text = deferred.await()
        Toast.makeText(applicationContext, "MainScope", Toast.LENGTH_SHORT).show()
    }
}
复制代码


最后别忘了在 onDestroy() 中取消协程,通过扩展函数 cancel() 来实现:

override fun onDestroy() {
    super.onDestroy()
    cancel()
}
复制代码


现在来测试一下 launchFromMainScope() 方法吧!你会发现这完全符合你的需求。实际开发中可以把 MainScope 整合到 BaseActivity 中,就不需要重复书写模板代码了。


ViewModelScope

如果你使用了 MVVM 架构,根本就不会在 Activity 上书写任何逻辑代码,更别说启动协程了。这个时候大部分工作就要交给 ViewModel 了。那么如何在 ViewModel 中定义协程作用域呢?还记得上面 MainScope() 的定义吗?没错,搬过来直接使用就可以了。


class ViewModelOne : ViewModel() {
    private val viewModelJob = SupervisorJob()
    private val uiScope = CoroutineScope(Dispatchers.Main + viewModelJob)
    val mMessage: MutableLiveData<String> = MutableLiveData()
    fun getMessage(message: String) {
        uiScope.launch {
            val deferred = async(Dispatchers.IO) {
                delay(2000)
                "post $message"
            }
            mMessage.value = deferred.await()
        }
    }
    override fun onCleared() {
        super.onCleared()
        viewModelJob.cancel()
    }
}
复制代码


这里的 uiScope 其实就等同于 MainScope。调用 getMessage() 方法和之前的 launchFromMainScope() 效果也是一样的,记得在 ViewModel 的 onCleared() 回调里取消协程。


你可以定义一个 BaseViewModel 来处理这些逻辑,避免重复书写模板代码。然而 Kotlin 就是要让你做同样的事,写更少的代码,于是 viewmodel-ktx 来了。看到 ktx ,你就应该明白它是来简化你的代码的。引入如下依赖:

implementation "androidx.lifecycle:lifecycle-viewmodel-ktx:2.2.0-alpha03"
复制代码


然后,什么都不需要做,直接使用协程作用域 viewModelScope 就可以了。viewModelScope 是 ViewModel 的一个扩展属性,定义如下:

val ViewModel.viewModelScope: CoroutineScope
        get() {
            val scope: CoroutineScope? = this.getTag(JOB_KEY)
            if (scope != null) {
                return scope
            }
            return setTagIfAbsent(JOB_KEY,
                CloseableCoroutineScope(SupervisorJob() + Dispatchers.Main))
        }
复制代码


看下代码你就应该明白了,还是熟悉的那一套。当 ViewModel.onCleared() 被调用的时候,viewModelScope 会自动取消作用域内的所有协程。使用示例如下:

fun getMessageByViewModel() {
    viewModelScope.launch {
        val deferred = async(Dispatchers.IO) { getMessage("ViewModel Ktx") }
        mMessage.value = deferred.await()
    }
}
复制代码


写到这里,viewModelScope 是能满足需求的最简写法了。实际上,写完全篇,viewModelScope 仍然是我认为的最好的选择。


LiveData

Kotlin 同样为 LiveData 赋予了直接使用协程的能力。添加如下依赖:

implementation "androidx.lifecycle:lifecycle-livedata-ktx:2.2.0-alpha03"
复制代码


直接在 liveData {} 代码块中调用需要异步执行的挂起函数,并调用 emit() 函数发送处理结果。示例代码如下所示:

val mResult: LiveData<String> = liveData {
    val string = getMessage("LiveData Ktx")
    emit(string)
}
复制代码


你可能会好奇这里好像并没有任何的显示调用,那么,liveData 代码块是在什么执行的呢?当 LiveData 进入 active 状态时,liveData{ } 会自动执行。当 LiveData 进入 inactive 状态时,经过一个可配置的 timeout 之后会自动取消。如果它在完成之前就取消了,当 LiveData 再次 active 的时候会重新运行。如果上一次运行成功结束了,就不会再重新运行。也就是说只有自动取消的 liveData{ } 可以重新运行。其他原因(比如 CancelationException)导致的取消也不会重新运行。


所以 livedata-ktx 的使用是有一定限制的。对于需要用户主动刷新的场景,就无法满足了。在一次完整的生命周期内,一旦成功执行完成一次,就没有办法再触发了。 这句话不知道对不对,我个人是这么理解的。因此,还是 viewmodel-ktx 的适用性更广,可控性也更好。


LifecycleScope

implementation "androidx.lifecycle:lifecycle-runtime-ktx:2.2.0-alpha03"
复制代码


lifecycle-runtime-ktx 给每个 LifeCycle 对象通过扩展属性定义了协程作用域 lifecycleScope 。你可以通过 lifecycle.coroutineScope 或者 lifecycleOwner.lifecycleScope 进行访问。示例代码如下:

fun getMessageByLifeCycle(lifecycleOwner: LifecycleOwner) {
    lifecycleOwner.lifecycleScope.launch {
        val deferred = async(Dispatchers.IO) { getMessage("LifeCycle Ktx") }
        mMessage.value = deferred.await()
    }
}
复制代码


当 LifeCycle 回调 onDestroy() 时,协程作用域 lifecycleScope 会自动取消。在 Activity/Fragment 等生命周期组件中我们可以很方便的使用,但是在 MVVM 中又不会过多的在 View 层进行逻辑处理,viewModelScope 基本就可以满足 ViewModel 中的需求了,lifecycleScope 也显得有点那么食之无味。但是他有一个特殊的用法:

suspend fun <T> Lifecycle.whenCreated()
suspend fun <T> Lifecycle.whenStarted()
suspend fun <T> Lifecycle.whenResumed()
suspend fun <T> LifecycleOwner.whenCreated()
suspend fun <T> LifecycleOwner.whenStarted()
suspend fun <T> LifecycleOwner.whenResumed()
复制代码

可以指定至少在特定的生命周期之后再执行挂起函数,可以进一步减轻 View 层的负担。


总结


以上简单的介绍了在 Android 中合理使用协程的一些方案,示例代码已上传至 Github。关于 MVVM + 协程 的实战项目,可以看看我的开源项目 wanandroid,同时也期待你宝贵的意见。



相关文章
|
7月前
|
移动开发 数据库 Android开发
构建高效Android应用:Kotlin协程的实践指南
【5月更文挑战第30天】 在移动开发领域,性能优化和流畅的用户体验是至关重要的因素。对于Android开发者来说,Kotlin协程作为一种异步编程解决方案,提供了强大且轻量级的机制来处理后台任务,而不会对主线程造成阻塞。本文将深入探讨Kotlin协程的概念、优势以及如何在Android应用中实现它们,从而改善应用响应性和用户满意度。通过实例代码和最佳实践的分享,我们将展示如何有效利用协程来处理网络请求、数据库操作和耗时计算,同时确保UI的流畅性。
|
7月前
|
移动开发 调度 Android开发
构建高效Android应用:Kotlin协程的实践指南
【5月更文挑战第30天】在移动开发领域,Android平台的流畅性与效率一直是开发者追求的核心。随着Kotlin语言的普及,其提供的协程特性为编写高效、轻量级的异步代码提供了强大工具。本文将深入探讨如何在Android项目中利用Kotlin协程来优化性能,提升用户体验。我们将从协程的基本概念出发,通过实例演示如何在实际开发中合理运用协程,并讨论协程对资源管理和错误处理的影响。
40 3
|
7月前
|
移动开发 安全 Android开发
构建高效Android应用:Kotlin协程的实践与优化策略
【5月更文挑战第30天】 在移动开发领域,性能优化始终是关键议题之一。特别是对于Android开发者来说,如何在保证应用流畅性的同时,提升代码的执行效率,已成为不断探索的主题。近年来,Kotlin语言凭借其简洁、安全和实用的特性,在Android开发中得到了广泛的应用。其中,Kotlin协程作为一种新的并发处理机制,为编写异步、非阻塞性的代码提供了强大工具。本文将深入探讨Kotlin协程在Android开发中的应用实践,以及如何通过协程优化应用性能,帮助开发者构建更高效的Android应用。
|
2月前
|
JSON 调度 数据库
Android面试之5个Kotlin深度面试题:协程、密封类和高阶函数
本文首发于公众号“AntDream”,欢迎微信搜索“AntDream”或扫描文章底部二维码关注,和我一起每天进步一点点。文章详细解析了Kotlin中的协程、扩展函数、高阶函数、密封类及`inline`和`reified`关键字在Android开发中的应用,帮助读者更好地理解和使用这些特性。
38 1
|
3月前
|
Android开发 开发者 Kotlin
告别AsyncTask:一招教你用Kotlin协程重构Android应用,流畅度飙升的秘密武器
【9月更文挑战第13天】随着Android应用复杂度的增加,有效管理异步任务成为关键。Kotlin协程提供了一种优雅的并发操作处理方式,使异步编程更简单直观。本文通过具体示例介绍如何使用Kotlin协程优化Android应用性能,包括网络数据加载和UI更新。首先需在`build.gradle`中添加coroutines依赖。接着,通过定义挂起函数执行网络请求,并在`ViewModel`中使用`viewModelScope`启动协程,结合`Dispatchers.Main`更新UI,避免内存泄漏。使用协程不仅简化代码,还提升了程序健壮性。
106 1
|
4月前
|
调度 Android开发 开发者
【颠覆传统!】Kotlin协程魔法:解锁Android应用极速体验,带你领略多线程优化的无限魅力!
【8月更文挑战第12天】多线程对现代Android应用至关重要,能显著提升性能与体验。本文探讨Kotlin中的高效多线程实践。首先,理解主线程(UI线程)的角色,避免阻塞它。Kotlin协程作为轻量级线程,简化异步编程。示例展示了如何使用`kotlinx.coroutines`库创建协程,执行后台任务而不影响UI。此外,通过协程与Retrofit结合,实现了网络数据的异步加载,并安全地更新UI。协程不仅提高代码可读性,还能确保程序高效运行,不阻塞主线程,是构建高性能Android应用的关键。
66 4
|
5月前
|
开发者 Kotlin Android开发
Kotlin协程在Android开发中的应用
【7月更文挑战第10天】Kotlin协程简化了Android异步编程,提供轻量级并发。挂起函数让异步代码看起来同步,不阻塞线程,便于管理。在项目中,添加Kotlin和协程依赖,如`kotlinx.coroutines-core`和`kotlinx-coroutines-android`。使用`CoroutineScope`和`launch`处理耗时任务,如网络请求,避免主线程阻塞。挂起函数和调度器控制执行上下文,适应不同任务需求。
|
6月前
|
安全 Android开发 Kotlin
Android面试题之Kotlin协程并发问题和互斥锁
Kotlin的协程提供轻量级并发解决方案,如`kotlinx.coroutines`库。`Mutex`用于同步,确保单个协程访问共享资源。示例展示了`withLock()`、`lock()`、`unlock()`和`tryLock()`的用法,这些方法帮助在协程中实现线程安全,防止数据竞争。
87 1
|
6月前
|
存储 Java 调度
Android面试题之Kotlin 协程的挂起、执行和恢复过程
了解Kotlin协程的挂起、执行和恢复机制。挂起时,状态和上下文(局部变量、调用栈、调度器等)被保存;挂起点通过`Continuation`对象处理,释放线程控制权。当恢复条件满足,调度器重新分配线程,调用`resumeWith`恢复执行。关注公众号“AntDream”获取更多并发知识。
140 2
|
7月前
|
移动开发 数据库 Android开发
构建高效Android应用:Kotlin协程的全面应用指南
【5月更文挑战第30天】在移动开发领域,性能优化和流畅的用户体验始终是开发者追求的目标。随着Kotlin语言在Android平台的广泛采用,其提供的协程特性成为了实现这一目标的有力工具。本文将深入探讨如何在Android应用中使用Kotlin协程进行异步编程,提升应用的响应性和稳定性,同时保证代码的简洁性和可维护性。