Kotlin（九）探秘Kotlin协程机制

2401_84121897

390人浏览 · 2024-04-05 11:33:57

2401_84121897 · 2024-04-05 11:33:57 发布

fun updateUI()

协程写法

GlobalScope.launch(Dispatchers.Main){
val value1 = request1()
val deferred2 = GlobalScope.async{request2(value1)}
val deferred3 = GlobalScope.async{request3(value2)}
updateUI(deferred2.await(),deferred3.await())
}

suspend request1( )
suspend request2(…)
suspend request3(…)

协程的目的是为了让多个任务之间更好的协作,解决异步回调嵌套。能够以同步的方式编排代码完成异步工作。将异步代码像同步代码一样直观。同时它也是一个并发流程控制的解决方案。

协程主要是让原来要使用“异步+回调”写出来的复杂代码, 简化成看似同步写出来的方式,弱化了线程的概念（对线程的操作进一步抽象）

2.协程的用法

引入gradle依赖

//在kotlin项目中配合jetpack架构引入协程
api ‘androidx.lifecycle:lifecycle-viewmodel-ktx:2.2.0’
api ‘androidx.lifecycle:lifecycle-runtime-ktx:2.2.0’
api ‘androidx.lifecycle:lifecycle-livedata-ktx:2.2.0’

//在kotlin项目但非jetpack 架构项目中引入协程
api “org.jetbrains.kotlinx:kotlinx-coroutines-core:1.2.1”
api ‘org.jetbrains.kotlinx:kotlinx-coroutines-android:1.1.1’

常用的创建协程的方法

//创建协程时,可以通过Dispatchers.IO,MAIN,Unconfined指定协程运行的线程
val job:Job =GlobalScope.launch(Dispatchers.Main)
val deffered:Deffered=GlobalScope.async（Dispatchers.IO）

Job：协程构建函数的返回值，可以把 Job 看成协程对象本身，包含了对协程的控制方法。

Deffered是Job的子类，实际上就增加了个await方法。能够让当前协程暂时挂起,暂停往下执行。当await方法有返回值后,会恢复协程,继续往下执行

方法	说明
start()	手动启动协程
join()	等待协程执行完毕
cancel()	取消一个协程

协程的启动

public fun CoroutineScope.launch(
context: CoroutineContext = EmptyCoroutineContext,
start: CoroutineStart = CoroutineStart.DEFAULT,
block: suspend CoroutineScope.() -> Unit
): Job{
val newContext = newCoroutineContext(context)
val coroutine = StandaloneCoroutine(newContext, active = true)
coroutine.start(start, coroutine, block)
}

CoroutineContext - 可以理解为协程的上下文，是一种key-value数据结构

CoroutineContext	List
get(key: Key): E	get(int index)
plus(context: Element)	add(int index, E element)
minusKey(key: Key<*>)	remove(E element)

一个简单的例子

object CoroutineScene {

private const val TAG = “CoroutineScene”

fun startScene1(){
GlobalScope.launch (Dispatchers.Main){
Log.i(TAG,“startScene work on ${Thread.currentThread().name}”)
val result1 = request1()
val result2 = request2(result1)
val result3 = request3(result2)
updateUI(result3)
}
}

fun startScene2(){
GlobalScope.launch (Dispatchers.Main){
Log.i(TAG,“startScene work on ${Thread.currentThread().name}”)
val result1 = request1()

val deferred2 = GlobalScope.async { request2(result1) }
val deferred3 = GlobalScope.async { request3(result1) }
//不能单独调用await
updateUI(deferred2.await(),deferred3.await())
}
}

private fun updateUI(result: String) {
Log.i(TAG,“updateUI work on ${Thread.currentThread().name}”)
Log.i(TAG,“result: $result”)
}

private fun updateUI(result2:String,result3: String) {
Log.i(TAG,“updateUI work on ${Thread.currentThread().name}”)
Log.i(TAG,“result: ${result2}--$ {result3}”)
}

//suspend 关键字的作用?
//delay既然是IO异步任务，是如何做到延迟协程中的代码向下执行的?
suspend fun request1():String{
delay(2*1000) //延迟2秒,不会暂停线程，但会暂停当前的协程

Log.i(TAG,“request1 work on ${Thread.currentThread().name}”)
return “result from request1”
}

suspend fun request2(request:String):String{
delay(2*1000) //延迟2秒
Log.i(TAG,“request2 work on ${Thread.currentThread().name}”)
return “result from request2”
}

suspend fun request3(request:String):String{
delay(2*1000) //延迟2秒
Log.i(TAG,“request3 work on ${Thread.currentThread().name}”)
return “result from request3”
}
}

CoroutineDispatcher 协程运行的线程调度器

协程调度器

coroutine_dispatcher

模式	说明
Dispatchers.IO	显示指定协程运行的线程,为IO线程
Dispatchers.Main	指定这个协程运行在主线程
Dispatchers.Default	默认的,启动携程时会启动一个线程
Dispatchers.Unconfined	不指定，就是在当前线程运行,协程恢复后的运行的线程取决于协程挂起时所在的线程

CoroutineStart - 启动模式

默认是DEAFAULT，也就是创建就启动；还有一个是LAZY，意思是等你需要它的时候，再调用启动

模式	说明
CoroutineStart().DEAFAULT	模式模式，创建即启动协程,可随时取消
ATOMIC	自动模式,同样创建即启动,但启动前不可取消
LAZY	延迟启动模式，只有当调用start方法时才会启动

3.协程挂起,恢复原理逆向剖析

挂起函数

被关键字suspend修饰的方法在编译阶段,编译器会修改方法的签名.包括返回值,修饰符,入参,方法体实现。协程的挂起是靠挂起函数中实现的代码。

//kotlin
suspend fun request(): String {
delay(2 * 1000) //suspend fun()
println(“after delay”)
return “result from request”
}

转成java之后

//java
public static final Object request(Continuation completion) {
ContinuationImpl requestContinuation = completion;
if ((completion.label & Integer.MIN_VALUE) == 0)
requestContinuation = new ContinuationImpl(completion) {
@Override
Object invokeSuspend(Object o) {
label |= Integer.MIN_VALUE;
return request(this); //3.重新再次请求
}
};
}
switch (requestContinuation.label) {
case 0: { //1.第一次进来，执行方法，并且将标记改为1
requestContinuation.label = 1;
//2. 执行延迟操作，并将异步监听放进去，由此可见：协程的挂起其实是方法的挂起
Object delay = DelayKt.delay(2000, requestContinuation);
if (delay == COROUTINE_SUSPENDED) {
return COROUTINE_SUSPENDED;
}
}
}
//4.执行下面的方法
System.out.println(“after delay”)
return “result from request”;
}

协程挂起与协程恢复

协程的核心是挂起----恢复,挂起–恢复的本质是return & callback回调

coroutine_resume

模拟挂起和恢复的整个流程

object CoroutineScene2 {

private val TAG :String = “CoroutineScene2”

suspend fun request2():String{
delay(2*1000);
Log.i(TAG,“request2 completed”)
return “result from request2”;
}
}

Java

public class CoroutineScene2_decompiled {

private static final String TAG = “CoroutineScene2”;

//1.挂起流程
public static final Object request2(Continuation preCallback) {
ContinuationImpl request2Callback;

if (!(preCallback instanceof ContinuationImpl) || (((ContinuationImpl) preCallback).label & Integer.MAX_VALUE) == 0) {
request2Callback = new ContinuationImpl(preCallback) {
@Override
public Object invokeSuspend(@NotNull Object resumeResult) {
this.result = resumeResult;
this.label |= Integer.MAX_VALUE;
return request2(this);
}
};

} else {
request2Callback = (ContinuationImpl) preCallback;
}
switch (request2Callback.label){
case 0:
Object delay = DelayKt.delay(2000,request2Callback);
if(delay == IntrinsicsKt.getCOROUTINE_SUSPENDED()){
return IntrinsicsKt.getCOROUTINE_SUSPENDED();
}
}
Log.i(TAG,“request2 comleted”);
return “result from request 2”;
}

static abstract class ContinuationImpl implements Continuation {

Continuation preCallback;
int label;
Object result;

public ContinuationImpl(Continuation preCallback) {
this.preCallback = preCallback;
}

@NotNull
@Override
public CoroutineContext getContext() {
return preCallback.getContext();
}

//2.恢复流程
@Override
public void resumeWith(@NotNull Object result) {
Object suspend = invokeSuspend(result);
if(suspend == IntrinsicsKt.getCOROUTINE_SUSPENDED()){
return;
}
preCallback.resumeWith(suspend);
}

public abstract Object invokeSuspend(@NotNull Object resumeResult);
}

}

kotliin

object CoroutineScene2 {

private val TAG :String = “CoroutineScene2”

suspend fun request1():String{
val request2 :String = request2();
return “result from request1” + request2
}

suspend fun request2():String{
delay(2*1000);
Log.i(TAG,“request2 completed”)
return “result from request2”;
}
}

Java

public class CoroutineScene2_decompiled {

private static final String TAG = “CoroutineScene2”;
//1.挂起流程
public static final Object request1(Continuation preCallback) {
ContinuationImpl request1Callback;

if (!(preCallback instanceof ContinuationImpl) || (((ContinuationImpl) preCallback).label & Integer.MAX_VALUE) == 0) {
request1Callback = new ContinuationImpl(preCallback) {
@Override
public Object invokeSuspend(@NotNull Object resumeResult) {
this.result = resumeResult;
this.label |= Integer.MAX_VALUE;
Log.i(TAG,“request1 has resumed”);
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数初中级Android工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则近万的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Android移动开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Android开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注：Android）

学习宝典

对我们开发者来说，一定要打好基础，随时准备战斗。不论寒冬是否到来，都要把自己的技术做精做深。虽然目前移动端的招聘量确实变少了，但中高端的职位还是很多的，这说明行业只是变得成熟规范起来了。竞争越激烈，产品质量与留存就变得更加重要，我们进入了技术赋能业务的时代。

不论遇到什么困难，都不应该成为我们放弃的理由！

很多人在刚接触这个行业的时候或者是在遇到瓶颈期的时候，总会遇到一些问题，比如学了一段时间感觉没有方向感，不知道该从那里入手去学习，对此我针对Android程序员，我这边给大家整理了一套学习宝典！包括不限于高级UI、性能优化、移动架构师、NDK、混合式开发（ReactNative+Weex）微信小程序、Flutter等全方面的Android进阶实践技术；希望能帮助到大家，也节省大家在网上搜索资料的时间来学习，也可以分享动态给身边好友一起学习！

【Android核心高级技术PDF文档，BAT大厂面试真题解析】