【kotlin】- 携程的挂起和恢复

简介

使用kotlin携程,难免会使用到携程的挂起特性,正因为这些特性解决了kotlin等待异步执行结果的回调地狱,下面将从源码的角度来分析携程的挂起和恢复原理。

技巧

方法执行可以通过打印线程堆栈来看

    public static void printStackTrace(String msg) {
        StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace();

        println(Thread.currentThread() + ", message: [" + msg + "]");
        if (stackTrace == null || stackTrace.length < 2) {
            println("empty stack");
            return;
        }

        for (int i = 2; i < stackTrace.length; i++) {
            println("\tat " + stackTrace[i]);
        }
    }

    private static void println(Object object) {
        System.out.println(object);
    }

例子先行

  • 公用代码
     fun treadName(): String = Thread.currentThread().name
    
     suspend fun doSuspendOne(): Int {
        delay(1000L) // 假设我们在这里做了一些有用的事
        println("${treadName()}======doSuspendOne")
        return 13
    }
    
    suspend fun doSuspendTwo(): Int {
        delay(500L) // 假设我们在这里也做了一些有用的事
        println("${treadName()}======doSuspendTwo")
        return 29
    }
    
  • 第一个例子
    fun main() {
        runBlocking {
            doSuspendOne()
            doSuspendTwo()
        }
        println("${treadName()}======main")
    }
    
    输出如下:
    main======doSuspendOne
    main======doSuspendTwo
    main======main
    
    Process finished with exit code 0
    
  • 第二个例子
    suspend fun main() {
       doSuspendOne()
       doSuspendTwo()
       println("${treadName()}======main")
    }
    
    输出如下:
    kotlinx.coroutines.DefaultExecutor======doSuspendOne
    kotlinx.coroutines.DefaultExecutor======doSuspendTwo
    kotlinx.coroutines.DefaultExecutor======main
    
    Process finished with exit code 0
    
  • 第三个例子
     suspend fun main() {
         GlobalScope.launch {
             println("${treadName()}======launch1111")
             delay(300)
             println("${treadName()}======launch")
         }
         runBlocking {
             println("${treadName()}======runBlocking")
             doSuspendOne()
             doSuspendTwo()
         }
         println("${treadName()}======main")
     }
    
    输出如下:
    DefaultDispatcher-worker-1======launch1111
    main======runBlocking
    DefaultDispatcher-worker-1======launch
    main======doSuspendOne
    main======doSuspendTwo
    main======main
    
    Process finished with exit code 0
    
  • 第四个例子
    suspend fun main() {
        GlobalScope.launch {
            println("${treadName()}======launch1111")
            delay(300)
            println("${treadName()}======launch")
        }
        println("${treadName()}======main")
        Thread.sleep(3000)
    }
    
    输出如下
    main======main
    DefaultDispatcher-worker-1======launch1111
    DefaultDispatcher-worker-1======launch
    
    Process finished with exit code 0
    

挂起

特点是:挂起而不阻塞线程,这里要清楚一点,挂起的本质是切线程,并且在相应的逻辑处理完成之后,再重新切回线程。挂起使协程体的操作被return而停止,等待恢复,它阻塞的是协程体的操作,并未阻塞线程。

挂起函数底层实现

刚开始学习kotlin的同学可能不知道怎么分析kotlin相关功能代码,特别是语法糖相关的,其实不管kotlin语法糖再多,它最终要通过编译脱糖生成字节码,总是能够分析的。

下面将通过源码层面进行携程挂起恢复的讲解,这里只给出关键的源码位置,如果大家想一步步跟踪代码的执行逻辑,可以写一个简单的apk,里面包含简单的携程代码,利用Android Studio进行编译和脱糖相关处理,在用jadx进程反编译,查看。

通过 jdax发现部分代码不能反编译,那么我们可以结合Android Studio提供的kotlin反编译工具进行查看。

  • 负责协程体逻辑的处理(BaseContinuationImpl)

    internal abstract class BaseContinuationImpl(  
         // completion:实参是一个AbstractCoroutine  
         public val completion: Continuation?  
     ) : Continuation, CoroutineStackFrame, Serializable {  
         public final override fun resumeWith(result: Result) {  
                     ...
                         try {  
                             // 调用invokeSuspend方法,协程体真正开始执行  
                             val outcome = invokeSuspend(param)  
                             // invokeSuspend方法返回值为COROUTINE_SUSPENDED,resumeWith方法被return,结束执行,说明执行了挂起操作  
                             if (outcome === COROUTINE_SUSPENDED) return  
                             // 协程体执行成功的结果  
                             Result.success(outcome)  
                         } catch (exception: Throwable) {  
                             // 协程体出现异常的结果  
                             Result.failure(exception)  
                         }  
                     releaseIntercepted()   
                    
                     if (completion is BaseContinuationImpl) {               
                         ...  
                     } else {  
                         completion.resumeWith(outcome)  
                         return  
                    ...
    

    invokeSuspend()的执行就是协程体的执行,当invokeSuspend()返回值为COROUTINE_SUSPENDED时,会执行return操作,resumeWith()的执行被结束掉,协程体的操作也被结束掉了,而COROUTINE_SUSPENDED代表协程发生挂起。

    通过反编译可以发现我们编写的携程体会被转换成invokeSuspend方法调用 ,以这个例子进行反编译(我用的Android Studio自带的kotlin工具,和通过jadx反编译出来有所不同,但是挂起和恢复的逻辑都一样的)。

    suspend fun doSuspendOne(): Int {
        delay(1000) // 假设我们在这里做了一些有用的事
        println("${treadName()}======doSuspendOne")
        return 13
    }
    
    fun main(): Unit = runBlocking{
        doSuspendOne()
    }
    

    看一下invokeSuspend方法:

            public final Object invokeSuspend(@NotNull Object $result) {
            ...
             switch(this.label) {
             case 0:
                ...
                this.label = 1;
                if (TestKt.doSuspendOne(this) == var2) {
                   return var2;
                }
                break;
            ...
             }
            ...
           }
    

    doSuspendOne函数实现:

    public static final Object doSuspendOne(@NotNull Continuation var0) {
     Object $continuation;
     ...
       Object var5 = IntrinsicsKt.getCOROUTINE_SUSPENDED();
       switch((()$continuation).label) {
           case 0:
           ResultKt.throwOnFailure($result);
           (()$continuation).label = 1;
           if (DelayKt.delay(1000L, (Continuation)$continuation) == var5) {
           return var5;
       }
           break;
           case 1:
           ResultKt.throwOnFailure($result);
           break;
           default:
           throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
       }
    
       String var1 = KotlinCoroutinesTestKt.treadName() +   "======doSuspendOne";
       boolean var2 = false;
       System.out.println(var1);
       return Boxing.boxInt(13);
    }
    

    结合源码看一下,默认情况下label==0,i==0,执行label = 1赋值操作,及调用挂起函数delay(...),此处判断delay(...)方法返回值为coroutine_suspended时,就会返回 coroutine_suspended,也就是当delay(...)内存在挂起操作的时候它的返回值就是coroutine_suspended

    假设delay(...)挂起函数内执行了挂起操作,delay(...)方法结束并返回coroutine_suspended,resumeWith()方法在收到返回值coroutine_suspended也进行了return操作,resumeWith()和invokeSuspend()方法执行都结束了, println日志打印并没有得到执行,协程挂起并不是阻塞了当前的线程(通过上面第三个例子输出可以看出),而是执行了return操作,结束了协程体的调用。

    挂起函数内执行挂起操作的时候会返回coroutine_suspended标志,结束协程体的运行,使协程挂起,接下来看下协程提供的挂起函数中是如何操作的。

  • 携程恢复
    恢复外部协程时,通过线程调度,将协程在指定线程运行,这样也就可以在挂起恢复时,重新切回线程,再次触发invokeSuspend(),根据label状态值,执行下一个代码片。

    结论
    在DispatchedCoroutine中,重写了afterCompletion()及afterResume(),并且afterCompletion()调用afterResume(),而afterResume()中首先判断了协程是否被挂起,如已挂起则恢复外部的协程。恢复外部协程时,同样是通过线程调度,将协程在指定线程运行,这样也就可以在挂起恢复时,重新切回线程,再次触发invokeSuspend(),根据label状态值,执行下一个代码片。本质就是:将携程体代码分成一个个执行代码块,通过label控制执行那一个代码块,当执行到需要挂起的代码块会挂起,然后返回结束协调体执行,当挂起部分恢复时,重新在指定线程调用invokeSuspend方法,这是label变成下一个要执行的代码块的值

你可能感兴趣的:(【kotlin】- 携程的挂起和恢复)