少年，你可知 Kotlin 协程最初的样子？

已于 2023-02-05 17:51:50 修改
阅读量843 收藏 2
点赞数
分类专栏： Kotlin 从现在开始学 文章标签： kotlin android java
于 2022-06-15 18:18:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wekajava/article/details/125302284
版权

前言

协程系列文章：

如果有人问你，怎么开启一个 Kotlin 协程？你可能会说通过runBlocking/launch/async，回答没错，这几个函数都能开启协程。不过这次咱们换个角度分析，通过提取这几个函数的共性，看看他们内部是怎么开启一个协程的。
相信通过本篇，你将对协程原理有个深刻的认识。
文章目录：

1、suspend 关键字背后的原理
2、如何开启一个原始的协程？
3、协程调用以及整体流程
4、协程代码我为啥看不懂？

1、suspend 关键字背后的原理

suspend 修饰函数

普通的函数

fun launchEmpty(block: () -> Unit) {   
}

定义一个函数，形参为函数类型。
查看反编译结果：

public final class CoroutineRawKt {
    public static final void launchEmpty(@NotNull Function0 block) {
    }
}

可以看出，在JVM 平台函数类型参数最终是用匿名内部类表示的，而FunctionX(X=0~22) 是Kotlin 将函数类型映射为Java 的接口。
来看看Function0 的定义：

public interface Function0<out R> : Function<R> {
    /** Invokes the function. */
    public operator fun invoke(): R
}

有一个唯一的方法：invoke()，它没有任何参数。
可作如下调用：

fun launchEmpty(block: () -> Unit) {
    block()//与block.invoke()等价
}
fun main(array: Array<String>) {
    launchEmpty {
        println("I am empty")
    }
}

带suspend 的函数

以上写法大家都比较熟悉了，就是典型的高阶函数的定义和调用。
现在来改造一下函数类型的修饰符：

fun launchEmpty1(block: suspend () -> Unit) {
}

相较之前，加了"suspend"关键字。
老规矩，查看反编译结果：

public static final void launchEmpty1(@NotNull Function1 block) {
}

参数从Function0 变为了Function1：

/** A function that takes 1 argument. */
public interface Function1<in P1, out R> : Function<R> {
    /** Invokes the function with the specified argument. */
    public operator fun invoke(p1: P1): R
}

Function1 的invoke()函数多了一个入参。

也就是说，加了suspend 修饰后，函数会默认加个形参。

当我们调用suspend修饰的函数时：
image.png
意思是：

"suspend"修饰的函数只能在协程里被调用或者是在另一个被"suspend"修饰的函数里调用。

suspend 作用

何为挂起

suspend 意为挂起、阻塞的意思，与协程相关。
当suspend 修饰函数时，表明这个函数可能会被挂起，至于是否被挂起取决于该函数里是否有挂起动作。
比如：

suspend fun testSuspend() {
    println("test suspend")
}

这样的写法没意义，因为函数没有实现挂起功能。
你可能会说，挂起需要切换线程，好嘛，换个写法：

suspend fun testSuspend() {
    println("test suspend")
    thread {
        println("test suspend in thread")
    }
}

然而并没啥用，编译器依然提示：
image.png

意思是可以不用suspend 修饰，没啥意义。

挂起于协程的意义

第一点
当函数被suspend 修饰时，表明协程执行到此可能会被挂起，若是被挂起那么意味着协程将无法再继续往下执行，直到条件满足恢复了协程的运行。

fun main(array: Array<String>) {
    GlobalScope.launch {
        println("before suspend")//①
        testSuspend()//挂起函数②
        println("after suspend")//③
    }
}

执行到②时，协程被挂起，将不会执行③，直到协程被恢复后才会执行③。
注：关于协程挂起的生动理解&线程的挂起 下篇将着重分析。

第二点
如果将suspend 修饰的函数类型看做一个整体的话：

suspend () -> T

无参，返回值为泛型。
Kotlin 里定义了一些扩展函数，可用来开启协程。

第三点
suspend 修饰的函数类型，当调用者实现其函数体时，传入的实参将会继承自SuspendLambda（这块下个小结详细分析）。

2、如何开启一个原始的协程？

launch/async/runBlocking 如何开启协程

纵观这几种主流的开启协程方式，它们最终都会调用到：

#CoroutineStart.kt
    public operator fun <R, T> invoke(block: suspend R.() -> T, receiver: R, completion: Continuation<T>): Unit =
        when (this) {
            DEFAULT -> block.startCoroutineCancellable(receiver, completion)
            ATOMIC -> block.startCoroutine(receiver, completion)
            UNDISPATCHED -> block.startCoroutineUndispatched(receiver, completion)
            LAZY -> Unit // will start lazily
        }

无论走哪个分支，都是调用block的函数，而block 就是我们之前说的被suspend 修饰的函数。
以DEFAULT 为例startCoroutineUndispatched接下来会调用到IntrinsicsJvm.kt里的：

#IntrinsicsJvm.kt
public actual fun <R, T> (suspend R.() -> T).createCoroutineUnintercepted(
    receiver: R,
    completion: Continuation<T>
)

该函数带了俩参数，其中的receiver 为接收者，而completion 为协程结束后调用的回调。
为了简单，我们可以省略掉receiver。
刚好IntrinsicsJvm.kt 里还有另一个函数：

#IntrinsicsJvm.kt
public actual fun <T> (suspend () -> T).createCoroutineUnintercepted(
    completion: Continuation<T>
): Continuation<Unit>

createCoroutineUnintercepted 为 (suspend () -> T) 类型的扩展函数，因此只要我们的变量为 (suspend () -> T)类型就可以调用createCoroutineUnintercepted(xx)函数。
查找该函数的使用之处，发现Continuation.kt 文件里不少扩展函数都调用了它。
如：

#Continuation.kt
//创建协程的函数
public fun <T> (suspend () -> T).createCoroutine(
    completion: Continuation<T>
): Continuation<Unit> =
    SafeContinuation(createCoroutineUnintercepted(completion).intercepted(), COROUTINE_SUSPENDED)

其中Continuation 为接口：

#Continuation.kt
interface Continuation<in T> {
    //协程上下文
    public val context: CoroutineContext
    //恢复协程
    public fun resumeWith(result: Result<T>)
}

Continuation 接口很重要，协程里大部分的类都实现了该接口，通常直译过来为：“续体”。

创建完成后，还需要开启协程函数：

#Continuation.kt
//启动协程的函数
public inline fun <T> Continuation<T>.resume(value: T): Unit =
    resumeWith(Result.success(value))

简单创建/调用协程

协程创建

由上分析可知，Continuation.kt 里有我们开启协程所需要的一些基本信息，接着来看看如何调用上述函数。

fun <T> launchFish(block: suspend () -> T) {
    //创建协程，返回值为SafeContinuation(实现了Continuation 接口)
    //入参为Continuation 类型，参数名为completion，顾名思义就是
    //协程结束后(正常返回&抛出异常）将会调用它。
    var coroutine = block.createCoroutine(object : Continuation<T> {
        override val context: CoroutineContext
            get() = EmptyCoroutineContext

        //协程结束后调用该函数
        override fun resumeWith(result: Result<T>) {
            println("result:$result")
        }
    })
    //开启协程
    coroutine.resume(Unit)
}

定义了函数launchFish，该函数唯一的参数为函数类型参数，被suspend 修饰，而(suspend () -> T)定义一系列扩展函数，createCoroutine 为其中之一，因此block 可以调用createCoroutine。
createCoroutine 返回类型为SafeContinuation，通过SafeContinuation.resume()开启协程。

协程调用

fun main(array: Array<String>) {
    launchFish {
        println("I am coroutine")
    }
}

打印结果：
image.png

3、协程调用以及整体流程

协程调用背后的玄机

反编译初窥门径

看到上面的打印大家可能比较晕，"println(“I am coroutine”)"是咋就被调用的？没看到有调用它的地方啊。
launchFish(block) 接收的是函数类型，当调用launchFish 时，在闭包里实现该函数的函数体即可，我们知道函数类型最终会替换为匿名内部类。
因为kotlin 有不少语法糖，无法一下子直击本质，老规矩，反编译看看结果：

    public static final void main(@NotNull String[] array) {
        launchFish((Function1)(new Function1((Continuation)null) {
            int label;

            @Nullable
            public final Object invokeSuspend(@NotNull Object var1) {
                Object var4 = IntrinsicsKt.getCOROUTINE_SUSPENDED();
                switch(this.label) {
                    case 0:
                        //闭包里的内容
                        String var2 = "I am coroutine";
                        boolean var3 = false;
                        //打印
                        System.out.println(var2);
                        return Unit.INSTANCE;
                }
            }

            @NotNull
            public final Continuation create(@NotNull Continuation completion) {
                //创建一个Continuation，可以认为是续体
                Function1 var2 = new <anonymous constructor>(completion);
                return var2;
            }

            public final Object invoke(Object var1) {
                //Function1 接口里的方法
                return ((<undefinedtype>)this.create((Continuation)var1)).invokeSuspend(Unit.INSTANCE);
            }
        }));
    }

为了更直观，删除了一些不必要的信息。
看到这，你发现了什么？通常传入函数类型的实参最后将会被编译为对应的匿名内部类，此时应该编译为Function1，实现其唯一的函数：invoke(xx)，而我们发现实际上还多了两个函数：invokeSuspend(xx)与create(xx)。
我们有理由相信，invokeSuspend(xx)函数一定在某个地方被调用了，原因是：闭包里打印的字符串：“I am coroutine” 只在该函数里实现，而我们测试的结果是这个打印执行了。
还记得我们上面说的suspend 意义的第三点吗？

suspend 修饰的函数类型，其实参是匿名内部类，继承自抽象类：SuspendLambda。

也就是说invokeSuspend(xx)与create(xx) 的定义很有可能来自SuspendLambda，我们接着来分析它。

SuspendLambda 关系链

#ContinuationImpl.kt
internal abstract class SuspendLambda(
    public override val arity: Int,
    completion: Continuation<Any?>?
) : ContinuationImpl(completion), FunctionBase<Any?>, SuspendFunction {
    constructor(arity: Int) : this(arity, null)
    ...
}

该类本身并没有太多内容，此处继承了ContinuationImpl类，查看该类也没啥特殊的，继续往上查找，找到BaseContinuationImpl类，在里面发现了线索：

#ContinuationImpl.kt
internal abstract class BaseContinuationImpl(
    val completion: Continuation<Any?>?
) : Continuation<Any?>, CoroutineStackFrame, Serializable {
    protected abstract fun invokeSuspend(result: Result<Any?>): Any?
    open fun create(completion: Continuation<*>): Continuation<Unit> {
    }
}

终于看到了眼熟的：invokeSuspend(xx)与create(xx)。
我们再回过头来捋一下类之间关系：
image.png
闭包生成的匿名内部类：

  • 实现了Function1 接口，并实现了该接口里的invoke函数。
  • 继承了SuspendLambda，并重写了invokeSuspend函数和create函数。

你可能会说还不够直观，那好，继续改写一下：

    class MyAnonymous extends SuspendLambda implements Function1 {
        int label;
        public final Object invokeSuspend(@NotNull Object var1) {
            Object var4 = IntrinsicsKt.getCOROUTINE_SUSPENDED();
            switch(this.label) {
                case 0:
                    String var2 = "I am coroutine";
                    boolean var3 = false;
                    System.out.println(var2);
                    return Unit.INSTANCE;
            }
        }
        public final Continuation create(@NotNull Continuation completion) {
            Intrinsics.checkNotNullParameter(completion, "completion");
            Function1 var2 = new <anonymous constructor>(completion);
            return var2;
        }
        public final Object invoke(Object var1) {
            return ((<undefinedtype>)this.create((Continuation)var1)).invokeSuspend(Unit.INSTANCE);
        }
    }

    public static final void launchFish(@NotNull MyAnonymous block) {
        Continuation coroutine = ContinuationKt.createCoroutine(block, (new Continuation() {
            @NotNull
            public CoroutineContext getContext() {
                return (CoroutineContext) EmptyCoroutineContext.INSTANCE;
            }

            public void resumeWith(@NotNull Object result) {
                String var2 = "result:" + Result.toString-impl(result);
                boolean var3 = false;
                System.out.println(var2);
            }
        }));
        //开启
        coroutine.resumeWith(Result.constructor-impl(var3));
    }

    public static final void main(@NotNull String[] array) {
        MyAnonymous myAnonymous = new MyAnonymous();
        launchFish(myAnonymous);
    }

这么看就比较清晰了，此处我们单独声明了一个MyAnonymous类，并构造对象传递给launchFish函数。

闭包的执行

既然匿名类的构造清晰了，接下来分析闭包是如何被执行的，也就是查找invokeSuspend(xx)函数是怎么被调用的？
将目光转移到launchFish 函数本身。

createCoroutine()
先看createCoroutine()函数调用，直接上代码：

#Continuation.kt
fun <T> (suspend () -> T).createCoroutine(
    completion: Continuation<T>
): Continuation<Unit> =
    //返回SafeContinuation 对象
    //SafeContinuation 构造函数需要2个参数，一个是delegate，另一个是协程状态
    //此处默认是挂起
    SafeContinuation(createCoroutineUnintercepted(completion).intercepted(), COROUTINE_SUSPENDED)

#IntrinsicsJvm.kt
actual fun <T> (suspend () -> T).createCoroutineUnintercepted(
    completion: Continuation<T>
): Continuation<Unit> {
    val probeCompletion = probeCoroutineCreated(completion)
    return if (this is BaseContinuationImpl)
        //此处的this 即为匿名内部类对象 MyAnonymous，它间接继承了BaseContinuationImpl
        //调用MyAnonymous 重写的create 函数
        //create 函数里new 新的MyAnonymous 对象
        create(probeCompletion)
    else
        createCoroutineFromSuspendFunction(probeCompletion) {
            (this as Function1<Continuation<T>, Any?>).invoke(it)
        }
}

#IntrinsicsJvm.kt
public actual fun <T> Continuation<T>.intercepted(): Continuation<T> =
    //判断是否是ContinuationImpl 类型的Continuation
    //我们的demo里是true，因此会继续尝试调用拦截器
    (this as? ContinuationImpl)?.intercepted() ?: this

#ContinuationImpl.kt
public fun intercepted(): Continuation<Any?> =
    //查看是否已经有拦截器，如果没有，则从上下文里找，上下文没有，则用自身，最后赋值。
    //在我们的demo里上下文里没有，用的是自身
    intercepted
        ?: (context[ContinuationInterceptor]?.interceptContinuation(this) ?: this)
            .also { intercepted = it }

最后得出的Continuation 赋值给SafeContinuation 的成员变量：delegate。
至此，SafeContinuation 对象已经构造完毕，接着继续看如何用它开启协程。

再看 resume()

#SafeContinuationJvm.kt
actual override fun resumeWith(result: Result<T>) {
    while (true) { // lock-free loop
        val cur = this.result // atomic read
        when {
            //初始化状态为UNDECIDED，因此直接return
            cur === CoroutineSingletons.UNDECIDED -> if (SafeContinuation.RESULT.compareAndSet(this,
                    CoroutineSingletons.UNDECIDED, result.value)) return
            //如果是挂起，将它变为恢复状态，并调用恢复函数
           //demo 里初始化状态为COROUTINE_SUSPENDED，因此会走到这
            cur === COROUTINE_SUSPENDED -> if (SafeContinuation.RESULT.compareAndSet(this, COROUTINE_SUSPENDED,
                    CoroutineSingletons.RESUMED)) {
                //delegate 为之前创建的Continuation，demo 里因为没有拦截，因此为MyAnonymous
                delegate.resumeWith(result)
                return
            }
            else -> throw IllegalStateException("Already resumed")
        }
    }
}

#ContinuationImpl.kotlin
#BaseContinuationImpl类的成员函数
override fun resumeWith(result: Result<Any?>) {
    var current = this
    var param = result
    while (true) {
        probeCoroutineResumed(current)
        with(current) {
            val completion = completion!!
            val outcome: Result<Any?> =
                try {
                    //invokeSuspend 即为MyAnonymous 里的方法
                    val outcome = invokeSuspend(param)
                    //如果返回值是挂起状态，则函数直接退出
                    if (outcome === kotlin.coroutines.intrinsics.COROUTINE_SUSPENDED) return
                    kotlin.Result.success(outcome)
                } catch (exception: Throwable) {
                    kotlin.Result.failure(exception)
                }
            releaseIntercepted() // this state machine instance is terminating
            if (completion is BaseContinuationImpl) {
                current = completion
                param = outcome
            } else {
                //执行到这，最终执行外层的completion，在demo里会输出"result:$result"
                completion.resumeWith(outcome)
                return
            }
        }
    }
}

最后再回头看 invokeSuspend

         public final Object invokeSuspend(@NotNull Object var1) {
            Object var4 = IntrinsicsKt.getCOROUTINE_SUSPENDED();
            switch(this.label) {
            case 0:
               ResultKt.throwOnFailure(var1);
               String var2 = "I am coroutine";
               boolean var3 = false;
               System.out.println(var2);
               return Unit.INSTANCE;
            default:
               throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
            }
         }

你兴许已经发现了，此处的返回值永远是Unit.INSTANCE啊，那么协程永远不会挂起。
没有挂起功能的协程就是鸡肋…。
没错，咱们的demo里实现的是一个无法挂起的协程，回到最初的launchFish()的调用：

    launchFish {
        println("I am coroutine")
    }
}

因为闭包里只有一个打印语句，根本没有挂起函数，当然就没有挂起的说法了。

协程调用整体流程

上面花很多篇幅去分析协程的调用，其实就是为了从kotlin 的简洁里脱离出来，从而真正了解其背后的原理。
Demo里的协程构造比较原始，相较于launch/async 等启动方式，它没有上下文、没有线程调度，但并不妨碍我们通过它去了解协程的运作。当我们了解了其运作的核心，到时候再去看launch/async/runBlocking 就非常容易了，毕竟它们都是提供给开发者更方便操作协程的工具，是在原始携程的基础上演变的。
协程创建调用栈简易图：
image.png

4、协程代码我为啥看不懂？

之前有一些小伙伴跟我反馈说：“小鱼人，我尝试去看协程源码，感觉找不到入口，又或是跟着源码跟到一半就断了…你是咋阅读的啊？”
有一说一，协程源码确实不太好懂，若要比较顺畅读懂源码，根据个人经验可能需要以下前置条件：

1、kotlin 语法基础，这是必须的。
2、高阶函数&扩展函数。
3、平台代码差异，有一些类、函数是与平台相关，需要定位到具体平台，比如SafeContinuation，找到Java 平台的文件：SafeContinuationJvm.kt。
4、断点调试时，有些单步断点不会进入，需要指定运行到的位置。
5、有些代码是编译时期构造的，需要对照反编译结果查看。
6、还有些代码是没有源码的，可能是ASM插入的，此时只能靠肉眼理解了。

如果你对kotlin 基础/高阶函数 等有疑惑，请查看之前的文章。

本篇仅仅构造了一个简陋的协程，协程的最重要的挂起/恢复并没有涉及，下篇将会着重分析如何构造一个挂起函数，以及协程到底是怎么挂起的。

本文基于Kotlin 1.5.3，文中完整Demo请点击

您若喜欢，请点赞、关注，您的鼓励是我前进的动力

持续更新中，和我一起步步为营系统、深入学习Android/Kotlin

1、Android各种Context的前世今生
2、Android DecorView 必知必会
3、Window/WindowManager 不可不知之事
4、View Measure/Layout/Draw 真明白了
5、Android事件分发全套服务
6、Android invalidate/postInvalidate/requestLayout 彻底厘清
7、Android Window 如何确定大小/onMeasure()多次执行原因
8、Android事件驱动Handler-Message-Looper解析
9、Android 键盘一招搞定
10、Android 各种坐标彻底明了
11、Android Activity/Window/View 的background
12、Android Activity创建到View的显示过
13、Android IPC 系列
14、Android 存储系列
15、Java 并发系列不再疑惑
16、Java 线程池系列
17、Android Jetpack 前置基础系列
18、Android Jetpack 易学易懂系列
19、Kotlin 轻松入门系列

小鱼人爱编程
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
讲真，Kotlin 协程的挂起没那么神秘(原理篇)
06-20 1502
上篇从拟物的角度阐述了协程挂起/恢复的场景，相信大家对此应该有了一个感性的的认识。上上篇分析了如何开启一个原始的协程，相信大家也知道协程内部执行原理了。本篇将重点分析协程挂起与恢复的原理，探究协程凭什么能挂起？它又为何能够在原地恢复？........................
kotlin 携程
最新发布
heeheeai的博客
06-25 443
挂起函数可以在不阻塞线程的情况下挂起执行，并在稍后恢复。协程运行在特定的上下文中，调度器 (Dispatcher) 决定了协程运行的线程或线程池。决定了协程在哪个线程池上执行。是一个协程的句柄，它表示协程的生命周期，并允许显式地取消协程。要使用挂起函数，需要在协程上下文中启动它。它们只能在协程或另一个挂起函数内调用。可以组合多个挂起函数，实现复杂的异步操作。启动一个新的协程，不返回任何结果。，它的子协程失败不会取消父协程。上执行代码块，并返回结果。协程中的异常处理可以使用。协程中的异常处理可以使用。
Kotlin协程：协程的基础与使用
热门推荐
LeeDuoZuiShuai的博客
07-24 1万+
协程是Coroutine的中文简称，co表示协同、协作，routine表示程序。协程可以理解为多个互相协作的程序。协程是轻量级的线程，它的轻量体现在启动和切换，协程的启动不需要申请额外的堆栈空间；协程的切换发生在用户态，而非内核态，避免了复杂的系统调用。...
kotlin语法进阶 - 协程（一）协程基础
weixin_43864176的博客
08-08 3611
kotlin协程基础
Kotlin 协程的基本概念及用法
金戈鐡馬
05-30 4207
在 Kotlin 中，协程就是基于线程来实现的一种更上层的工具 API，类似于 Android 自带的 Handler 系列 API。使用了协程的代码看似阻塞，但由于协程内部做了很多工作（包括自动切换线程），它实际上是非阻塞的。此处的 launch 方法含义是：创建一个新的协程，并在指定的线程上运行它。传给 launch 方法的连续代码段就被叫做一个协程，传给 launch 方法的方法参数可以用于指定执行这段代码的线程。协程在写法上和普通的顺序代码类似，可以让开发者用同步的方式写出异步的代码。
kotlin-coroutine-demo:kotlin协程demo，kotlin协程+ mvvm + okhttp
04-02
Kotlin协程演示下方对kotlin协程的原理进行的分析感觉有点长，还有点杂，后面有时间再整理一下演示说明kotlin协程演示，kotlin协程+ mvvm + okhttp，内部提供mvc与mvvm的不同实现，换下主活动在打包即可界面如下，...
java重量级源码-kotlin-coroutines-okhttp:用于OkHttp调用的Kotlin协程await()扩展
06-05
java重量级源码Kotlin 协程等待 OkHttp3 的扩展 这是一个小型库，提供await()扩展以与 Kotlin 协程集成 以实施为基础。 需要 Kotlin 1.3+ 取决于所以不需要更新到需要 Java 8+ 或 Android 5+ 用法 // Create OkHttp ...
一篇文章揭开Kotlin协程的神秘面纱
01-20
Kotlin协程是一种高级的并发机制，旨在解决Android开发中的异步问题，提供了一种更加简洁、可读性更强的编程模型。协程允许开发者编写看似同步的代码，但实际上它们在后台异步执行，避免了回调地狱的问题。通过将...
使用kotlin协程提高app性能(译)
08-25
使用 Kotlin 协程提高 App 性能 以下是使用 Kotlin 协程提高 App 性能的相关知识点： 1. 什么是协程 协程是一种并发设计模式，可以在 Android 上使用它来简化异步执行的代码。Kotlin 1.3 版本添加了 Coroutines，...
KLuban:Lifecycle + Kotlin 协程 + flow + LiveData + Glide 识别和内存优化 + Luban采样算法 = KLuban图片压缩
04-30
本项目是基于Luban算法，重构后实现的图片压缩框架KLuban 使用Kotlin + 协程 + Flow(并行任务) + LiveData(监听回调) + Glide图片识别和内存优化 + 邻近(鲁班)、双线性采样图片算法压缩框架，欢迎改进 fork 和 star...
【Android】一起掌握Kotlin协程基础
m0_64365896的博客
02-14 178
在平时的开发中，我们经常会跟线程打交道，当执行耗时操作时，便需要开启线程去执行，防止主线程阻塞。但是开启太多的线程，它们的切换就需要耗费很多的资源，并且难以去控制，没有及时停止或者控制不当便很可能会造成内存泄露。并且在开启多线程后，为了能够获取到计算结果，我们需要采用回调的方式来回调结果，但是回调多了，代码的可读性变得很差。kotlin协程是运行在线程之上，我们使用它时能够很好地去控制它，并且在切换方面，它消耗的CPU和内存大大地降低，它不会阻塞所在线程，可以在不用使用回调的情况下便可以直接获取计算结果。
Kotlin协程分析（三）——理解协程上下文
catzifeng的博客
07-20 1045
Kotlin协程分析（三）——理解协程上下文一、简单介绍 CoroutineContext二、CoroutineContext 的数据结构1."put"（进一步了解CoroutineContext的数据结构）1.1 EmptyCoroutineContext 协程上下文——CoroutineContext 是协程中很重要的环节，可以这么说，几乎整个协程的业务能力都是由它去完成的。 说实话，这段源码不是很好看，要具体解释出来也比较困难，如果在接下来的阅读过程中有任何疑惑，我们一起探讨学习。 一、简单介绍 Co
Kotlin 携程。Class类里面创建携程任务 CoroutineScope
丿灬安之若死
02-03 572
官方网址。
你不知道的CoroutineContext：协程上下文大揭秘！
xiaokangss的博客
12-27 913
协程（Coroutine）是一种并发编程技术，它允许我们在一个线程中执行多个任务，而不需要创建多个线程。协程与线程的区别在于，线程是操作系统的概念，而协程是编程语言的概念。协程可以暂停和恢复执行，而线程只能被终止。在 Android 中，协程由 Kotlin 语言支持。Kotlin 协程库提供了丰富的 API，可以帮助我们轻松地编写并发代码。其中，是一个非常重要的概念，它定义了协程的执行环境。在本篇文章中，我们将从以下几个方面来介绍的概念的组成的继承的注意事项总而言之，是协程的一个重要概念。
Kotlin 协程实现原理
gqg_guan的博客
08-08 3235
Kotlin 协程实现原理
Kotlin 启动协程顺序、launch 与async的区别、按照顺序启动协程 等待携程
丿灬安之若死
06-12 1135
launch 与async的区别 按照顺序启动协程现在有三个协程。想要先启动1之后再启动2 和3如何操作 ，luanch启动的话 使用 join函数 async的话 使用 await join和await 都是挂起函数，都不会阻塞主线程
kotlin协程async await的异常踩坑以及异常处理的正确姿势
喻志强的博客
10-30 5724
使用Kotlin来做一些异步操作相信大家都非常熟悉了，特别是结合Jetpack的一些组件，使得我们在Android开发中写异步任务非常的方便。 但是，关于在使用协程的时候，个人觉得异常处理这一块是相对来讲是需要花时间去了解的地方，因为在使用过程中还是会遇到一些小坑的，这里记录下之前遇到的坑。 踩一个使用async await时异常处理的坑 kotlin 协程的异常处理官方文档 我们先来看官方的示例： 可以看到，示例代码中在对 async 开启的协程进行异常捕获是在调用 await 时。看打印结果也确实是捕
JAVA SE 8 学习笔记（三）使用lambda编程
呵呵哈哈
05-08 2247
三、使用lambda编程 3.1 延迟执行 所有lambda表达式都是延迟执行的，如果希望立即执行一段代码，则没必要使用lambda表达式 延迟执行代码原因可能有： ·在另一个线程中运行代码 ·多次运行代码 ·在某个算法的正确时间点上运行代码 ·在某些情况发生时运行代码(如按钮点击、数据到达) ·只有在需要时运行代码 例如： public sta
Kotlin协程深度解析：入门到实践
"Kotlin协程指南是一份详细的教程，旨在帮助初学者理解并掌握Kotlin协程。本文档由pengrb撰写，提供了丰富的示例和深入的解释，覆盖了从协程的基础概念到高级特性，如取消、超时、挂起函数、协程上下文、调度器、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值