我的编程空间,编程开发者的网络收藏夹
学习永远不晚

一文彻底搞懂Kotlin中的协程

短信预约 -IT技能 免费直播动态提醒
省份

北京

  • 北京
  • 上海
  • 天津
  • 重庆
  • 河北
  • 山东
  • 辽宁
  • 黑龙江
  • 吉林
  • 甘肃
  • 青海
  • 河南
  • 江苏
  • 湖北
  • 湖南
  • 江西
  • 浙江
  • 广东
  • 云南
  • 福建
  • 海南
  • 山西
  • 四川
  • 陕西
  • 贵州
  • 安徽
  • 广西
  • 内蒙
  • 西藏
  • 新疆
  • 宁夏
  • 兵团
手机号立即预约

请填写图片验证码后获取短信验证码

看不清楚,换张图片

免费获取短信验证码

一文彻底搞懂Kotlin中的协程

产生背景

为了解决异步线程产生的回调地狱


//传统回调方式
api.login(phone,psd).enquene(new Callback<User>(){
 public void onSuccess(User user){
 api.submitAddress(address).enquene(new Callback<Result>(){
 public void onSuccess(Result result){
 ...
 }
 });
 }
});

//使用协程后
val user=api.login(phone,psd)
api.submitAddress(address)
...

协程是什么

本质上,协程是轻量级的线程。

协程关键名词


val job = GlobalScope.launch {
 delay(1000)
 println("World World!")
}

CoroutineScope(作用范围)

控制协程代码块执行的线程,生命周期等,包括GlobeScope、lifecycleScope、viewModelScope以及其他自定义的CoroutineScope

GlobeScope:全局范围,不会自动结束执行

lifecycleScope:生命周期范围,用于activity等有生命周期的组件,在DESTROYED的时候会自动结束,需额外引入

viewModelScope:viewModel范围,用于ViewModel中,在ViewModel被回收时会自动结束,需额外引入

Job(作业)

协程的计量单位,相当于一次工作任务,launch方法默认返回一个新的Job

suspend(挂起)

作用于方法上,代表该方法是耗时任务,例如上面的delay方法


public suspend fun delay(timeMillis: Long) {
 ...
}

协程的引入

主框架($coroutines_version替换为最新版本,如1.3.9,下同)


implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:$coroutines_version"

lifecycleScope(可选,版本2.2.0)


implementation 'androidx.activity:activity-ktx:$lifecycle_scope_version'

viewModelScope(可选,版本2.3.0-beta01)


implementation "androidx.lifecycle:lifecycle-viewmodel-ktx:$coroutines_viewmodel_version"

简单使用

先举个简单例子


lifecycleScope.launch { 
 delay(2000)
 tvTest.text="Test"
}

上面这个例子实现的功能是等待2秒,然后修改id为tvTest的TextView控件的text值为Test

自定义延迟返回方法

在kotlin里面,对于需要延迟才能返回结果的方法,需要用suspend标明


lifecycleScope.launch {
 val text=getText()
 tvTest.text = text
}

suspend fun getText():String{
 delay(2000)
 return "getText"
}

如果在其他线程,需要使用Continuation进行线程切换,可使用suspendCancellableCoroutine 或 suspendCoroutine包裹(前者可取消,相当于后者的扩展),成功调用it.resume(),失败调用it.resumeWithException(Exception()),抛出异常


suspend fun getTextInOtherThread() = suspendCancellableCoroutine<String> {
 thread {
 Thread.sleep(2000)
 it.resume("getText")
 }
}

异常捕获

协程里面的失败都可以通过异常捕获,来统一处理特殊情况


lifecycleScope.launch {
 try {
 val text=getText()
 tvTest.text = text
 } catch (e:Exception){
 e.printStackTrace()
 }
}

取消功能

下面执行了两个job,第一个是原始的,第二个是在1秒后取消第一个job,这会导致tvText的文本并不会改变


val job = lifecycleScope.launch {
 try {
 val text=getText()
 tvTest.text = text
 } catch (e:Exception){
 e.printStackTrace()
 }
}
lifecycleScope.launch {
 delay(1000)
 job.cancel()
}

设置超时

这个相当于系统封装了自动取消功能,对应函数withTimeout


lifecycleScope.launch {
 try {
 withTimeout(1000) {
  val text = getText()
  tvTest.text = text
 }
 } catch (e:Exception){
 e.printStackTrace()
 }
}

带返回值的Job

与launch类似的还有一个async方法,它会返回一个Deferred对象,属于Job的扩展类,Deferred可以获取返回的结果,具体使用如下


lifecycleScope.launch {
 val one= async {
 delay(1000)
 return@async 1
 }
 val two= async {
 delay(2000)
 return@async 2
 }
 Log.i("scope test",(one.await()+two.await()).toString())
}

高级进阶

自定义CoroutineScope

先看CoroutineScope源码


public interface CoroutineScope {
 public val coroutineContext: CoroutineContext
}

CoroutineScope中主要包含一个coroutineContext对象,我们要自定义只需实现coroutineContext的get方法


class TestScope() : CoroutineScope {
 override val coroutineContext: CoroutineContext
  get() = TODO("Not yet implemented")
}

要创建coroutineContext,得要先知道CoroutineContext是什么,我们再看CoroutineContext源码



public interface CoroutineContext {
 public operator fun <E : Element> get(key: Key<E>): E?
 public fun <R> fold(initial: R, operation: (R, Element) -> R): R
 public operator fun plus(context: CoroutineContext): CoroutineContext = 
  ...
 public fun minusKey(key: Key<*>): CoroutineContext
 
 public interface Key<E : Element>
 public interface Element : CoroutineContext {
  ...
 }
}

通过注释说明,我们知道它本质就是一个包含Element的集合,只是不像set和map集合一样,它自己实现了获取(get),折叠(fold,添加和替换的组合),相减(minusKey,移除),对象组合(plus,如val coroutineContext=coroutineContext1+coroutineContext2)
它的主要内容是Element,而Element的实现有

  • Job 任务
  • ContinuationInterceptor 拦截器
  • AbstractCoroutineContextElement
  • CoroutineExceptionHandler
  • ThreadContextElement
  • DownstreamExceptionElement
  • ....

可以看到很多地方都有实现Element,它主要目的是限制范围以及异常的处理。这里我们先了解两个重要的Element,一个是Job,一个是CoroutineDispatcher
Job

  • Job:子Job取消,会导致父job和其他子job被取消;父job取消,所有子job被取消
  • SupervisorJob:父job取消,所有子job被取消

CoroutineDispatcher

  • Dispatchers.Main:主线程执行
  • Dispatchers.IO:IO线程执行

我们模拟一个类似lifecycleScope的自定义TestScope


class TestScope() : CoroutineScope {
 override val coroutineContext: CoroutineContext
  get() = SupervisorJob() +Dispatchers.Main
}

这里我们定义了一个总流程线SupervisorJob()以及具体执行环境Dispatchers.Main(Android主线程),假如我们想替换掉activity的lifecycleScope,就需要在activity中创建实例


val testScope=TestScope()

然后在activity销毁的时候取消掉所有job


override fun onDestroy() {
 testScope.cancel()
 super.onDestroy()
}

其他使用方式同lifecycleScope,如


testScope.launch{
 val text = getText()
 tvTest.text = text
}

深入理解Job

CoroutineScope中包含一个主Job,之后调用的launch或其他方法创建的job都属于CoroutineScope的子Job,每个job都有属于自己的状态,其中包括isActive、isCompleted、isCancelled,以及一些基础操作start()、cancel()、join(),具体的转换流程如下

我们先从创建job开始,当调用launch的时候默认有三个参数CoroutineContext、CoroutineStart以及代码块参数。

  • context:CoroutineContext的对象,默认为CoroutineStart.DEFAULT,会与CoroutineScope的context进行折叠
  • start:CoroutineStart的对象,默认为CoroutineStart.DEFAULT,代表立即执行,同时还有CoroutineStart.LAZY,代表非立即执行,必须调用job的start()才会开始执行

val job2= lifecycleScope.launch(start = CoroutineStart.LAZY) {
 delay(2000)
 Log.i("scope test","lazy")
}
job2.start()

当使用这种模式创建时默认就是new状态,此时isActive,isCompleted,isCancelled都为false,当调用start后,转换为active状态,其中只有isActive为true,如果它的任务完成了则会进入Completing状态,此时为等待子job完成,这种状态下还是只有isActive为true,如果所有子job也完成了则会进入Completed状态,只有isCompleted为true。如果在active或Completing状态下出现取消或异常,则会进入Cancelling状态,如果需要取消父job和其他子job则会等待它们取消完成,此时只有isCancelled为true,取消完成后最终进入Cancelled状态,isCancelled和isCompleted都为true

State isActive isCompleted isCancelled
New FALSE FALSE FALSE
Active TRUE FALSE FALSE
Completing TRUE FALSE FALSE
Cancelling FALSE FALSE TRUE
Cancelled FALSE TRUE TRUE
Completed FALSE TRUE FALSE

不同job交互需使用join()与cancelAndJoin()

  • join():将当前job添加到其他协程任务里面
  • cancelAndJoin():取消操作,只是添加进去后再取消

val job1= GlobleScope.launch(start = CoroutineStart.LAZY) {
 delay(2000)
 Log.i("scope test","job1")
}
lifecycleScope.launch {
 job1.join()
 delay(2000)
 Log.i("scope test","job2")
}

深入理解suspend

suspend作为kotlin新增的方法修饰词,最终实现还是java,我们先看它们的差异性


suspend fun test1(){}
fun test2(){}

对应java代码


public final Object test1(@NotNull Continuation $completion) {
 return Unit.INSTANCE;
}
public final void test2() {
}

对应字节码


public final test1(Lkotlin/coroutines/Continuation;)Ljava/lang/Object;
 ...
 L0
 LINENUMBER 6 L0
 GETSTATIC kotlin/Unit.INSTANCE : Lkotlin/Unit;
 ARETURN
 L1
 LOCALVARIABLE this Lcom/lieni/android_c/ui/test/TestActivity; L0 L1 0
 LOCALVARIABLE $completion Lkotlin/coroutines/Continuation; L0 L1 1
 MAXSTACK = 1
 MAXLOCALS = 2

public final test2()V
 L0
 LINENUMBER 9 L0
 RETURN
 L1
 LOCALVARIABLE this Lcom/lieni/android_c/ui/test/TestActivity; L0 L1 0
 MAXSTACK = 0
 MAXLOCALS = 1

可以看到,加了suspend的方法其实和普通方法一样,只是传入时多了个Continuation对象,并返回了Unit.INSTANCE对象


public interface Continuation<in T> {
  public val context: CoroutineContext
  public fun resumeWith(result: Result<T>)
}

而Continuation的具体实现在BaseContinuationImpl中


internal abstract class BaseContinuationImpl(...) : Continuation<Any?>, CoroutineStackFrame, Serializable {
  public final override fun resumeWith(result: Result<Any?>) {
    ...
    while (true) {
      ...
      with(current) {
       	val outcome = invokeSuspend(param)
        ...
        releaseIntercepted() 
        if (completion is BaseContinuationImpl) {
          ...
        } else {
          ...
          return
        }
      }
    }
  }
  ...
}

当我们调用resumeWith时,它会一直执行一个循环,调用invokeSuspend(param)和releaseIntercepted() ,直到最顶层completion执行完成后返回,并且释放协程的interceptor

最终的释放在ContinuationImpl中实现


internal abstract class ContinuationImpl(...) : BaseContinuationImpl(completion) {
  ...
  protected override fun releaseIntercepted() {
    val intercepted = intercepted
    if (intercepted != null && intercepted !== this) {
      context[ContinuationInterceptor]!!.releaseInterceptedContinuation(intercepted)
    }
    this.intercepted = CompletedContinuation 
  }
}

通过这里知释放最终通过CoroutineContext中为ContinuationInterceptor的Element来实现
而暂停也是同理,继续看suspendCoroutine


public suspend inline fun <T> suspendCoroutine(crossinline block: (Continuation<T>) -> Unit): T =
  suspendCoroutineUninterceptedOrReturn { c: Continuation<T> ->
    val safe = SafeContinuation(c.intercepted())
    ...
  }

默认会调用Continuation的intercepted()方法


internal abstract class ContinuationImpl(...) : BaseContinuationImpl(completion) {
  ...
  public fun intercepted(): Continuation<Any?> =intercepted
      ?: (context[ContinuationInterceptor]?.interceptContinuation(this) ?: this)
        .also { intercepted = it }
}

可以看到暂停最终也是通过CoroutineContext中为ContinuationInterceptor的Element来实现

流程总结(线程切换)

  • 创建新的Continuation
  • 调用CoroutineScope中的context的ContinuationInterceptor的interceptContinuation方法暂停父任务
  • 执行子任务(如果指定了线程,则在新线程执行,并传入Continuation对象)
  • 执行完毕后用户调用Continuation的resume或者resumeWith返回结果
  • 调用CoroutineScope中的context的ContinuationInterceptor的releaseInterceptedContinuation方法恢复父任务

阻塞与非阻塞

CoroutineScope默认是不会阻塞当前线程的,如果需要阻塞可以使用runBlocking,如果在主线程执行下面代码,会出现2s白屏


runBlocking { 
  delay(2000)
  Log.i("scope test","runBlocking is completed")
}

阻塞原理:执行runBlocking默认会创建BlockingCoroutine,而BlockingCoroutine中会一直执行一个循环,直到当前Job为isCompleted状态才会跳出循环


public fun <T> runBlocking(...): T {
  ...
  val coroutine = BlockingCoroutine<T>(newContext, currentThread, eventLoop)
  coroutine.start(CoroutineStart.DEFAULT, coroutine, block)
  return coroutine.joinBlocking()
}

private class BlockingCoroutine<T>(...) : AbstractCoroutine<T>(parentContext, true) {
  ...
  fun joinBlocking(): T {
   ...
   while (true) {
    ...
    if (isCompleted) break
    ...
   }  
   ...
  }
}

总结

到此这篇关于一文彻底搞懂Kotlin中协程的文章就介绍到这了,更多相关Kotlin协程内容请搜索编程网以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程网!

免责声明:

① 本站未注明“稿件来源”的信息均来自网络整理。其文字、图片和音视频稿件的所属权归原作者所有。本站收集整理出于非商业性的教育和科研之目的,并不意味着本站赞同其观点或证实其内容的真实性。仅作为临时的测试数据,供内部测试之用。本站并未授权任何人以任何方式主动获取本站任何信息。

② 本站未注明“稿件来源”的临时测试数据将在测试完成后最终做删除处理。有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

一文彻底搞懂Kotlin中的协程

下载Word文档到电脑,方便收藏和打印~

下载Word文档

猜你喜欢

一文彻底搞懂 DvaJS 原理

dva 首先是一个基于redux[1]和redux-saga[2]的数据流方案,然后为了简化开发体验,dva 还额外内置了react-router[3]和fetch[4],所以也可以理解为一个轻量级的应用框架。
DvaJS前端Dva2024-12-03

一文带你彻底搞懂Vuex

Vuex 是一个专为 Vue.js 应用程序开发的状态管理模式 + 库。它采用集中式存储管理应用的所有组件的状态,并以相应的规则保证状态以一种可预测的方式发生变化。
2022-11-22

一文彻底搞懂线程安全问题

本文将基于生产者消费者模式加一个个具体案例,循序渐进的讲解线程安全问题的诞生背景以及解决方案,一文帮你抓住synchronized的应用场景,以及与Lock的区别。
线程安全2024-12-02

一文彻底搞懂前端沙箱

运行不信任的代码是非常困难的,只依赖软件模块作为沙箱技术,防止不受信任代码用于非正当用途是不得已的决定。

一文彻底搞懂前端监控

前端监控的第一个步骤就是数据采集,采集的信息包含环境信息、性能信息、异常信息、业务信息。

一文彻底搞懂“内存管理”

笔者面试过不少业务后台开发候选人,当问起内存管理的相关问题时,往往都会答出 JVM 的垃圾回收机制,并对 Serial、Parallel、CMS 等收集器如数家珍,侃侃而谈。

IO多路复用,一文彻底搞懂!

本文分析了多种 IO模型,重点讲解了 IO多路复用原理及其每种方式的源码分析。
IO模型网络2024-11-29

彻底搞懂 Kubernetes 中的 Events

既然 events 是 Kubernetes 集群中的一种资源,正常情况下它的 metadata.name 中应该包含其名称,用于进行单独操作。

一文彻底搞懂zookeeper核心知识点

Zookeeper 它作为Hadoop项目中的一个开源子项目,是一个经典的分布式数据一致性解决方案,致力于为分布式应用提供一个高性能、高可用,且具有严格顺序访问控制能力的分布式协调服务。

头条面试官:一文彻底搞懂 JSONP

JSONP,全称 JSON with Padding,为了解决跨域的问题而出现。虽然它只能处理 GET 跨域,虽然现在基本上都使用 CORS 跨域,但仍然要知道它,毕竟面试会问。

彻底搞懂 python 中文乱码问题

前言曾几何时 Python 中文乱码的问题困扰了我很多很多年,每次出现中文乱码都要去网上搜索答案,虽然解决了当时遇到的问题但下次出现乱码的时候又会懵逼,究其原因还是知其然不知其所以然。现在有的小伙伴为了躲避中文乱码的问题甚至代码中不使用中文
2023-01-31

一文让你彻底搞懂Vuex,满满的干货

可以把多个组件都需要的变量全部存储到一个对象里面,然后这个对象放在顶层的 vue 实例中,让其他组件可以使用。这样多个组件就可以共享这个对象中的所有属性。

编程热搜

  • Android:VolumeShaper
    VolumeShaper(支持版本改一下,minsdkversion:26,android8.0(api26)进一步学习对声音的编辑,可以让音频的声音有变化的播放 VolumeShaper.Configuration的三个参数 durati
    Android:VolumeShaper
  • Android崩溃异常捕获方法
    开发中最让人头疼的是应用突然爆炸,然后跳回到桌面。而且我们常常不知道这种状况会何时出现,在应用调试阶段还好,还可以通过调试工具的日志查看错误出现在哪里。但平时使用的时候给你闹崩溃,那你就欲哭无泪了。 那么今天主要讲一下如何去捕捉系统出现的U
    Android崩溃异常捕获方法
  • android开发教程之获取power_profile.xml文件的方法(android运行时能耗值)
    系统的设置–>电池–>使用情况中,统计的能耗的使用情况也是以power_profile.xml的value作为基础参数的1、我的手机中power_profile.xml的内容: HTC t328w代码如下:
    android开发教程之获取power_profile.xml文件的方法(android运行时能耗值)
  • Android SQLite数据库基本操作方法
    程序的最主要的功能在于对数据进行操作,通过对数据进行操作来实现某个功能。而数据库就是很重要的一个方面的,Android中内置了小巧轻便,功能却很强的一个数据库–SQLite数据库。那么就来看一下在Android程序中怎么去操作SQLite数
    Android SQLite数据库基本操作方法
  • ubuntu21.04怎么创建桌面快捷图标?ubuntu软件放到桌面的技巧
    工作的时候为了方便直接打开编辑文件,一些常用的软件或者文件我们会放在桌面,但是在ubuntu20.04下直接直接拖拽文件到桌面根本没有效果,在进入桌面后发现软件列表中的软件只能收藏到面板,无法复制到桌面使用,不知道为什么会这样,似乎并不是很
    ubuntu21.04怎么创建桌面快捷图标?ubuntu软件放到桌面的技巧
  • android获取当前手机号示例程序
    代码如下: public String getLocalNumber() { TelephonyManager tManager =
    android获取当前手机号示例程序
  • Android音视频开发(三)TextureView
    简介 TextureView与SurfaceView类似,可用于显示视频或OpenGL场景。 与SurfaceView的区别 SurfaceView不能使用变换和缩放等操作,不能叠加(Overlay)两个SurfaceView。 Textu
    Android音视频开发(三)TextureView
  • android获取屏幕高度和宽度的实现方法
    本文实例讲述了android获取屏幕高度和宽度的实现方法。分享给大家供大家参考。具体分析如下: 我们需要获取Android手机或Pad的屏幕的物理尺寸,以便于界面的设计或是其他功能的实现。下面就介绍讲一讲如何获取屏幕的物理尺寸 下面的代码即
    android获取屏幕高度和宽度的实现方法
  • Android自定义popupwindow实例代码
    先来看看效果图:一、布局
  • Android第一次实验
    一、实验原理 1.1实验目标 编程实现用户名与密码的存储与调用。 1.2实验要求 设计用户登录界面、登录成功界面、用户注册界面,用户注册时,将其用户名、密码保存到SharedPreference中,登录时输入用户名、密码,读取SharedP
    Android第一次实验

目录