Kotlin（九，阿里P7大牛亲自教你

最新推荐文章于 2024-06-13 10:35:51 发布

深圳安卓开发王者

最新推荐文章于 2024-06-13 10:35:51 发布

阅读量119

点赞数

分类专栏： Android 文章标签： kotlin 移动开发

本文链接：https://blog.csdn.net/m0_61418455/article/details/120122771

版权

Android 专栏收录该内容

18 篇文章 0 订阅

订阅专栏

协程的启动

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<T> implements Continuation<T> {

        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");
                    return request1(this);
                }
            };

        } else {
            request1Callback = (ContinuationImpl) preCallback;
        }
        switch (request1Callback.label){
            case 0:
                //Object delay = DelayKt.delay(2000,request2Callback);
                Object request2= request2(request1Callback);
                if(request2 == IntrinsicsKt.getCOROUTINE_SUSPENDED()){
                    Log.i(TAG,"request1 has suspended");
                    return IntrinsicsKt.getCOROUTINE_SUSPENDED();
                }
        }
        Log.i(TAG,"request2 completed");
        return "result1 from request1 " + request1Callback.result;
    }



    //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
### 总结

最后对于程序员来说，要学习的知识内容、技术有太多太多，要想不被环境淘汰就只有不断提升自己，**从来都是我们去适应环境，而不是环境来适应我们！**

这里附上上述的技术体系图相关的几十套**腾讯、头条、阿里、美团等公司2021年的面试题**，把技术点整理成了视频和PDF（实际上比预期多花了不少精力），包含**知识脉络 + 诸多细节**，由于篇幅有限，这里以图片的形式给大家展示一部分。

**相信它会给大家带来很多收获：**

![](https://img-blog.csdnimg.cn/img_convert/a503d74fe36ce70a611c5026889a9e81.png)

![](https://img-blog.csdnimg.cn/img_convert/ae86340e5978a2c46cfa482afb6445e7.png)

**[CodeChina开源项目：《Android学习笔记总结+移动架构视频+大厂面试真题+项目实战源码》](https://codechina.csdn.net/m0_60958482/android_p7)**

术体系图相关的几十套**腾讯、头条、阿里、美团等公司2021年的面试题**，把技术点整理成了视频和PDF（实际上比预期多花了不少精力），包含**知识脉络 + 诸多细节**，由于篇幅有限，这里以图片的形式给大家展示一部分。

**相信它会给大家带来很多收获：**

[外链图片转存中...(img-PnBSGw7I-1630851647395)]

[外链图片转存中...(img-8kTG5nRj-1630851647397)]

**[CodeChina开源项目：《Android学习笔记总结+移动架构视频+大厂面试真题+项目实战源码》](https://codechina.csdn.net/m0_60958482/android_p7)**

> 当程序员容易，当一个优秀的程序员是需要不断学习的，从初级程序员到高级程序员，从初级架构师到资深架构师，或者走向管理，从技术经理到技术总监，每个阶段都需要掌握不同的能力。早早确定自己的职业方向，才能在工作和能力提升中甩开同龄人。

深圳安卓开发王者

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Kotlin（九，阿里P7大牛亲自教你

| join() | 等待协程执行完毕 || cancel() | 取消一个协程 |协程的启动public fun CoroutineScope.launch( context: CoroutineContext = EmptyCoroutineContext, start: CoroutineStart = CoroutineStart.DEFAULT, block: suspend CoroutineScope.() -> Unit): Job{ val new
复制链接

扫一扫