Android面试题之Kotlin协程一文搞定

简介: 本文介绍了协程的基础知识,强调它是轻量级线程,用于处理耗时任务而不阻塞主线程,确保主线程安全。协程特点包括使异步逻辑同步化,并允许函数挂起和恢复。挂起函数由`suspend`关键字标识,只能在协程内部调用。挂起与阻塞的主要区别在于挂起不会导致主线程ANR。结构化并发和协程作用域(如`CoroutineScope`、`GlobalScope`、`MainScope`等)提供了任务管理,文章还探讨了并发、启动模式、协程取消、超时任务以及资源释放等主题。

本文首发于公众号“AntDream”,欢迎微信搜索“AntDream”或扫描文章底部二维码关注,和我一起每天进步一点点

定义

协程基于线程,是轻量级的线程

作用
  • 处理耗时任务,这种任务常常会阻塞主线程
  • 保证主线程安全,即确保安全地从主线程调用任何suspend函数
特点
  • 让异步逻辑同步化
  • 最核心的点就是,函数或者一段程序能够被挂起,稍后再在挂起得位置恢复
挂起函数
  • 使用suspend关键字修饰的函数
  • 挂起函数只能在协程体内或其他挂起函数内调用
挂起和阻塞的区别
  • 挂起不会阻塞主线程,主线程可以正常刷新UI,但阻塞就会导致主线程ANR
协程调度器
  • Dispatchers.Main:主线程上处理UI交互相关,更新LiveData
  • Dispatchers.IO:非主线程,磁盘读写和网络IO
  • Dispatchers.Default:非主线程,CPU密集型任务,排序,JSON数据解析等
任务泄漏
  • 当某个协程任务丢失,无法追踪,会导致内存、CPU、磁盘等资源浪费,甚至发送一个无用的网络请求,这种称为任务泄漏
  • 为了避免,引入了结构化并发机制
结构化并发
  • 可以取消任务、追踪任务、协程失败时发出错误信号
协程作用域CoroutineScope
  • 可以追踪所有协程,也可以取消协程
  • GlobalScope:生命周期是Process级别,即使Activity或Fragment已经被销毁,协程仍然运行
  • MainScope:在activity中使用,可以在onDestroy中取消协程
  • ViewModelScope:只能在ViewModel中使用,绑定ViewModel生命周期
  • lifecycleScope:只能在Activity、Fragment中使用,会绑定Activity、Fragment的生命周期
协程构建器

launch和async构建器都用来启动新协程

  • launch,返回一个Job并且不附带任何结果
  • async,返回一个Deferred,Deferred也是一个Job,可以使用.await()在一个延期的值上得到最终的结果
  • launch 是非阻塞的 而 runBlocking 是阻塞的。多个 withContext 任务是串行的, 且withContext 可直接返回耗时任务的结果。 多个 async 任务是并行的,async 返回的是一个Deferred<T>,需要调用其await()方法获取结果
  • runBlocking一般用在测试中,会阻塞当前线程,会等到包裹的子协程都执行完毕才退出
  • 事实上await()也不一定导致协程会被挂起,await() 只有在 async 未执行完成返回结果时,才会挂起协程。若 async 已经有结果了,await() 则直接获取其结果并赋值给变量,此时不会挂起协程
构建器 是否立即启动? 串行?并行? 是否阻塞当前线程? 返回结果
launch 根据包裹的子协程类型而定 Job对象
async 任务之间是并行 Deferred,可以用await()方法获取结果
runBlocking 根据包裹的子协程类型而定 阻塞 子协程都执行完毕后才退出
withContext 不是 任务之间是串行 可以直接返回耗时任务结果,协程体最后一行内容
doAsync和async
  • doAsync 的源码它的实现都是基于Java的 Future 类进行异步处理和通过Handler进行线程切换 ,从而封装的一个扩展函数方便线程切换。
  • 与 async 关系不大,因为 doAsync并没有用到协程库中的东西
  • 可以通过 uiThread { } 来切换会主线程
btn.setOnClickListener {
    doAsync {
        Log.e("TAG", " doAsync...   [当前线程为:${Thread.currentThread().name}]")
        uiThread {
            Log.e("TAG", " uiThread....   [当前线程为:${Thread.currentThread().name}]")
        }
    }
}
Job对象的生命周期
  • 每一个通过launch或者async创建的协程,都会返回一个Job实例,该实例时协程的唯一标识,负责管理协程的生命周期
  • 一个任务包含一系列状态:新创建(New)、活跃(Active)、完成中(Completing)、已完成(Completed)、取消中(Canceling)和已取消(Cancelled)。我们无法直接访问这些状态,可以通过访问Job的属性:isActive、isCancelled和isCompleted
  • 如果协程处于活跃状态,协程运行出错或是调用job.cancel(),都会将当前任务置为取消中(Cancelling)状态(isActive=false,isCancelled=true)。当所有子协程都完成后,协程会进入已取消(Cancelled)状态,此时isCompleted=true
  • 协程完成,可能是正常完成,也可能是被取消了
等待一个作业

由launch启动的协程用join()方法;用async启动的协程用await()

@Test
fun `test coroutine join`() = runBlocking {
    val job1 = launch {
        delay(200)
        println("job1 finished")
    }
    //这样可以确保job1执行完再执行后面的job2和job3
    job1.join()
    val job2 = launch {
        delay(200)
        println("job2 finished")
        //返回结果
        "job2 result"
    }

    val job3 = launch {
        delay(200)
        println("job3 finished")
        //返回结果
        "job2 result"
    }

}
组合并发
@Test
fun `test async`() = runBlocking {
    val time = measureTimeMillis {
        val one = doOne()
        val two = doTwo()
        //输出是30
        println("result: ${one + two}")
    }
    //输出是2秒多,也就是是串行的
    println(time)
}

//并发
@Test
fun `test combine async`() = runBlocking {
    val time = measureTimeMillis {
        val one = async { doOne() }
        val two = async { doTwo() }
        //输出是30
        println("result: ${one.await() + two.await()}")
    }
    //输出是1秒多,也就是是并行的
    println(time)
}

private suspend fun doOne(): Int{
    delay(1000)
    return 10
}
private suspend fun doTwo(): Int{
    delay(1000)
    return 20
}

注意async的写法不能是:

val one = async { doOne() }.await()
val two = async { doTwo() }.await()

这样起不到并发效果,而是等到one执行完,再执行two

协程的启动模式
  • DEFAULT:协程创建后,立即开始调度,在调度前如果协程被取消,其将直接进去取消响应状态
  • ATOMIC:协程创建后,立即开始调度,协程执行到第一个挂起点之前不响应取消

需要注意的是,立即调度不等于立即执行

  • LAZY:只有协程被需要时,包括主动调用协程的start、join或者await等函数时才会开始调度,如果调度前就被取消,那么该协程将直接进入异常结束状态
@Test
fun `test start mode`() = runBlocking {
    val job = async(start = CoroutineStart.LAZY) {
        //
    }
    //...其他代码
    //启动协程
    job.await()
}
  • UNDISPATCHED:协程创建后立即在当前函数调用栈中执行,直到遇到第一个真正的挂起点
@Test
fun `test start mode`() = runBlocking {
    val job = async(context = Dispatchers.IO, start = CoroutineStart.UNDISPATCHED) {
        println("thread:"+ Thread.currentThread().name)
    }
}
//上面输出的线程名字是主线程,因为UNDISPATCHED会立即在当前线程中执行,而runBlocking是在主线程中
协程作用域构建器 coroutineScope、runBlocking、supervisorScope
  • runBlocking是常规函数,会阻塞当前线程;coroutineScope是挂起函数,不会阻塞当前线程
  • 它们都会等待协程体以及所有子协程结束,一个是阻塞线程等待,一个是挂起等待
协程作用域构建器 coroutineScope、supervisorScope
  • coroutineScope,一个协程失败了,所有其他兄弟协程也会被取消
  • supervisorScope,一个子协程失败了,不会影响其他兄弟协程,但如果是作用域有异常失败了,则所有的子协程都会失败退出
coroutineScope和CoroutineScope
  • coroutineScope是一个挂起函数,是协程作用域构建器,CoroutineScope()是一个普通函数
  • coroutineScope后面的协程作用域的协程上下文是继承父协程作用域的上下文
  • CoroutineScope()有自己的作用域上下文
  • 都能够进行解构化并发,可以很好的管理多个子协程
协程的取消
  • 取消作用域会取消它的子协程
  • 被取消的子协程不会影响其余兄弟协程
  • 协程通过抛出一个特殊的异常CancellationException来处理取消操作
  • 所有kotlinx.coroutines中的挂起函数(withContext、delay等)都是可取消的
  • CPU密集型任务无法直接用cancel来取消
CPU密集型任务的取消
  • 通过isActive来判断取消,因为取消的任务isActive为false
  • 通过ensureActive()来取消,如果被取消,任务isActive为false,会抛一个异常
  • yield函数会检查所在协程的状态,如果已经取消,则抛出CancellationException予以响应。此外,它还会尝试出让线程的执行权,给其他协程提供执行的机会
协程取消的副作用
  • 在finally中释放资源
@Test
fun `test release resources`() = runBlocking {
    var br = BufferedReader(FileReader("xxx"))
    with(br){
        var line:String?
        try {
            while (true){
                line = readLine() ?: break
                println(line)
            }
        }finally {
            //关闭资源
            close()
        }
    }
}
  • 用use函数:该函数只能被实现了Closeable的对象使用,程序结束的时候会自动调用close方法,适合文件对象
//use函数在文件使用完毕后会自动调用close函数
BufferedReader(FileReader("xxx")).use {
    var line:String?
    while (true){
        line = readLine() ?: break
        println(line)
    }
}
不能取消的任务

协程被取消后,finally里面还有挂起函数,可以用withContext(NonCancellable)

@Test
fun `test cancel with noncancellable`() = runBlocking {
    val job = launch {
        try {
            repeat(1000){
                println("job: i'm sleeping $it")
                delay(500L)
            }
        }finally {
            //不用withContext(NonCancellable),delay后面的打印不会执行
            withContext(NonCancellable){
                println("running finally")
                delay(1000L)
                println("job: noncancellable")
            }
        }
    }
    delay(1300)
    println("main: waiting")
    job.cancelAndJoin()
    println("main: i can quit")
}
超时任务

withTimeout()方法可以开启超时任务,默认超时会抛出异常

/*
* 超时任务
* */
@Test
fun `test deal with timeout`() = runBlocking {
    withTimeout(1300){
        repeat(1000){
            println("job: sleeping $it")
            delay(500L)
        }
    }

}

如果不想抛出异常,可以用withTimeoutOrNull

 /*
* 超时任务,超时会返回null,不超时返回最后的done
* */
@Test
fun `test deal with timeout ornull`() = runBlocking {
    val result = withTimeoutOrNull(1300){
        repeat(1000){
            println("job: sleeping $it")
            delay(500L)
        }
        "done"
    }

    println("result: $result")
}

欢迎关注我的微信公众号AntDream,和我一起学习一起成长!

目录
相关文章
|
2天前
|
安全 Android开发 Kotlin
Android经典面试题之Kotlin中常见作用域函数
**Kotlin作用域函数概览**: `let`, `run`, `with`, `apply`, `also`. `let`安全调用并返回结果; `run`在上下文中执行代码并返回结果; `with`执行代码块,返回结果; `apply`配置对象后返回自身; `also`附加操作后返回自身
18 8
|
6天前
|
安全 Java Android开发
探索Android应用开发中的Kotlin语言
【7月更文挑战第19天】在移动应用开发的浩瀚宇宙中,Kotlin这颗新星以其简洁、安全与现代化的特性,正迅速在Android开发者之间获得青睐。从基本的语法结构到高级的编程技巧,本文将引导读者穿梭于Kotlin的世界,揭示其如何优化Android应用的开发流程并提升代码的可读性与维护性。我们将一起探究Kotlin的核心概念,包括它的数据类型、类和接口、可见性修饰符以及高阶函数等特性,并了解这些特性是如何在实际项目中得以应用的。无论你是刚入门的新手还是寻求进阶的开发者,这篇文章都将为你提供有价值的见解和实践指导。
|
3天前
|
SQL Java Unix
Android经典面试题之Java中获取时间戳的方式有哪些?有什么区别?
在Java中获取时间戳有多种方式,包括`System.currentTimeMillis()`(毫秒级,适用于日志和计时)、`System.nanoTime()`(纳秒级,高精度计时)、`Instant.now().toEpochMilli()`(毫秒级,ISO-8601标准)和`Instant.now().getEpochSecond()`(秒级)。`Timestamp.valueOf(LocalDateTime.now()).getTime()`适用于数据库操作。选择方法取决于精度、用途和时间起点的需求。
17 3
|
6天前
|
存储 前端开发 测试技术
Android Kotlin中使用 LiveData、ViewModel快速实现MVVM模式
使用Kotlin实现MVVM模式是Android开发的现代实践。该模式分离UI和业务逻辑,借助LiveData、ViewModel和DataBinding增强代码可维护性。步骤包括创建Model层处理数据,ViewModel层作为数据桥梁,以及View层展示UI。添加相关依赖后,Model类存储数据,ViewModel类通过LiveData管理变化,而View层使用DataBinding实时更新UI。这种架构提升代码可测试性和模块化。
33 2
|
1天前
|
消息中间件 调度 Android开发
Android经典面试题之View的post方法和Handler的post方法有什么区别?
本文对比了Android开发中`View.post`与`Handler.post`的使用。`View.post`将任务加入视图关联的消息队列,在视图布局后执行,适合视图操作。`Handler.post`更通用,可调度至特定Handler的线程,不仅限于视图任务。选择方法取决于具体需求和上下文。
7 0
|
存储 缓存 Java
Android--面试中遇到的问题总结(一)
版权声明:本文为博主原创文章,转载请标明出处。 https://blog.csdn.net/chaoyu168/article/details/56479430 一、handl...
1313 0
|
Android开发 容器 缓存
Android--面试中遇到的问题总结(二)
版权声明:本文为博主原创文章,转载请标明出处。 https://blog.csdn.net/chaoyu168/article/details/56480392 一、开发中都...
1230 0
|
算法 Java 程序员
Android--面试中遇到的问题总结(三)
《Android 开发工程师面试指南 LearningNotes 》,作者是陶程,由梁观全贡献部分。大家可以去知乎关注这两位用心的少年。
3008 0
|
14天前
|
开发工具 Android开发 iOS开发
探索Android与iOS开发的差异与挑战
【7月更文挑战第11天】在移动应用开发的广阔天地中,Android和iOS两大平台如同双子星座般耀眼,各自拥有独特的开发生态和用户群体。本文将深入分析这两个平台的显著差异,从技术架构到开发工具,再到市场定位,揭示它们之间的异同。通过比较,我们不仅能够更好地理解各自的优势和局限,还能洞察未来移动应用开发的趋势。
|
11天前
|
Android开发 Kotlin
kotlin开发安卓app,如何让布局自适应系统传统导航和全面屏导航
使用`navigationBarsPadding()`修饰符实现界面自适应,自动处理底部导航栏的内边距,再加上`.padding(bottom = 10.dp)`设定内容与屏幕底部的距离,以完成全面的布局适配。示例代码采用Kotlin。
51 15