协程-执行过程

如何使用 viewModelScope.launch 是一个非常常用的写法,它帮助在ViewModel中启动协程,执行异步任务,并确保在ViewModel销毁时取消协程,防止内存泄漏。在 Android 应用中,常用于执行网络请求、数据库操作等需要异步处理的任务。是的,中的代码可以使用来简化异常处理。是 Kotlin 标准库提供的一个函数,它用于捕获代码块中的异常,并以Result对象的形式返回。这样可以避免显式使用try-catch,使代码更加简洁。你完全可以将中的网络请求部分改造成,这样可以更优雅地处理异常并简化代码。 阅读详情

一、前言

在前面已经了解了协程的使用方法,为了能够更深入的了解协程的设计原理,那么我们来探究以下底层的实现原理。

二、执行过程分析

我们了解到,协程的创建和执行需要在CoroutineScope中,下面我们借助源码来分析CoroutineScope的执行过程。

2.1 创建CoroutineScope对象

    val scope = CoroutineScope(Job()+Dispatchers.IO)

CoroutineScope的创建很简单,传入一个CoroutineContext。

下面我们看一下CoroutineScope的代码:

/**
 * Creates a [CoroutineScope] that wraps the given coroutine [context].
 *
 * If the given [context] does not contain a [Job] element, then a default `Job()` is created.
 * This way, cancellation or failure of any child coroutine in this scope cancels all the other children,
 * just like inside [coroutineScope] block.
 */
public fun CoroutineScope(context: CoroutineContext): CoroutineScope =
    ContextScope(if (context[Job] != null) context else context + Job())

CoroutineScope返回一个根据我们传入的CoroutineContext进行包装,如果传入的context没有Job,那么会使用默认的Job(),CoroutineScope()函数返回ContextScope,ContextScope的代码比较简单,实现CoroutineScope接口,重写coroutineContext属性,并赋值。

internal class ContextScope(context: CoroutineContext) : CoroutineScope {
    override val coroutineContext: CoroutineContext = context
    // CoroutineScope is used intentionally for user-friendly representation
    override fun toString(): String = "CoroutineScope(coroutineContext=$coroutineContext)"
}

ContextScope的创建过程中,我们看到一个特殊的操作操作符“+”,这个对应的是CoroutineContext中的plus方法

public interface CoroutineContext {

    public operator fun plus(context: CoroutineContext): CoroutineContext =
        if (context === EmptyCoroutineContext) this else // fast path -- avoid lambda creation
            context.fold(this) { acc, element ->
                val removed = acc.minusKey(element.key)
                if (removed === EmptyCoroutineContext) element else {
                    // make sure interceptor is always last in the context (and thus is fast to get when present)
                    val interceptor = removed[ContinuationInterceptor]
                    if (interceptor == null) CombinedContext(removed, element) else {
                        val left = removed.minusKey(ContinuationInterceptor)
                        if (left === EmptyCoroutineContext) CombinedContext(element, interceptor) else
                            CombinedContext(CombinedContext(left, element), interceptor)
                    }
                }
            }
    
}

这里关于plus的具体实现可以参考源码中各个CoroutineContext子类的实现,下面用一张图来表示plus()函数最终的效果:
image

这里有个EmptyCoroutineContext对象,我们也需要了解一下它的实现:

public object EmptyCoroutineContext : CoroutineContext, Serializable {
    private const val serialVersionUID: Long = 0
    private fun readResolve(): Any = EmptyCoroutineContext

    public override fun <E : Element> get(key: Key<E>): E? = null
    public override fun <R> fold(initial: R, operation: (R, Element) -> R): R = initial
    public override fun plus(context: CoroutineContext): CoroutineContext = context
    public override fun minusKey(key: Key<*>): CoroutineContext = this
    public override fun hashCode(): Int = 0
    public override fun toString(): String = "EmptyCoroutineContext"
}

这里的EmptyCoroutineContext定义为了一个单例,实现CoroutineContext中相关的方法。

2.2 scope.launch()的执行过程分析

CoroutineScope创建完成后,需要通过launch函数来执行协程代码,下面分析launch函数的执行过程。

    scope.launch {
        print("this code execute in coroutine")
    }

launch后面的lambda就是我们协程,也是我们业务代码执行的代码块,下面看一下launch()函数

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

launch()是CoroutineScope的扩展方法,三个参数中,CoroutineContext和CoroutineStart都提供了默认的值,该方法最终返回一个Job。该方法首先通过newCoroutineContext()函数返回一个CoroutineContext,下面看一下newCoroutineContext()函数:

public actual fun CoroutineScope.newCoroutineContext(context: CoroutineContext): CoroutineContext {
    val combined = coroutineContext + context
    val debug = if (DEBUG) combined + CoroutineId(COROUTINE_ID.incrementAndGet()) else combined
    return if (combined !== Dispatchers.Default && combined[ContinuationInterceptor] == null)
        debug + Dispatchers.Default else debug
}

这个函数没有太多的逻辑,控制debug。CoroutineStart没有指定的情况下,默认的是CoroutineStart.DEFAULT,因此会进入coroutine = StandaloneCoroutine,接下来执行coroutine.start(start, coroutine, block),

    /**
     * Starts this coroutine with the given code [block] and [start] strategy.
     * This function shall be invoked at most once on this coroutine.
     *
     * First, this function initializes parent job from the `parentContext` of this coroutine that was passed to it
     * during construction. Second, it starts the coroutine based on [start] parameter:
     * 
     * * [DEFAULT] uses [startCoroutineCancellable].
     * * [ATOMIC] uses [startCoroutine].
     * * [UNDISPATCHED] uses [startCoroutineUndispatched].
     * * [LAZY] does nothing.
     */
    public fun <R> start(start: CoroutineStart, receiver: R, block: suspend R.() -> T) {
        initParentJob()
        start(block, receiver, this)
    }

接下来进入CoroutineStart的invoke()方法

public enum class CoroutineStart {

    ......
    
    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
        }

}

在launch()方法中,CoroutineStart默认是DEFAULT,接下来执行startCoroutineCancellable()

internal fun <R, T> (suspend (R) -> T).startCoroutineCancellable(
    receiver: R, completion: Continuation<T>,
    onCancellation: ((cause: Throwable) -> Unit)? = null
) =
    runSafely(completion) {
        createCoroutineUnintercepted(receiver, completion).intercepted().resumeCancellableWith(Result.success(Unit), onCancellation)
    }

private inline fun runSafely(completion: Continuation<*>, block: () -> Unit) {
    try {
        block()
    } catch (e: Throwable) {
        completion.resumeWith(Result.failure(e))
    }
}

最后

协程的内容很多,其中的suspend是很重要的一块,这块的实现逻辑还没有完全搞清楚,后期再来弥补这些内容。

STM32 IAP+APP合并Hex文件全自动脚本(Keil5一键生成) 本文详细介绍了一种基于Keil5开发环境的STM32 IAP与APP程序Hex文件全自动合并方案。通过编写批处理或Python脚本,并将其集成到Keil的编译后流程中,实现一键编译、自动合并,彻底解决手动操作繁琐易错的问题,极大提升STM32固件开发与远程升级的效率。 阅读详情

相关推荐

Unity 多线程编程笔记 _Task详解

士大夫

weixin_43405845的博客 4384

【深入理解Kotlin协程】CoroutineScope.launch源码追踪扒皮

coroutine.start的调用涉及到运算符重载,实际上最终会调到CoroutineStart.invoke()方法,在这个方法中根据当前的启动模式去分别执行不同方法,默认的启动模式是DEFAULT,因此这里走第一个分支。 同时注意到,DEFAULT模式下,这里startCoroutineCancellable方法的receiver和completion参数都是StandaloneCoroutine对象。在协程体的逻辑执行完后会调用到completion的resume方法恢复后面...

川峰的博客 2921

vTaskStartScheduler()详解

是启动 FreeRTOS 实时内核的“扳机”。在调用它之前,你只是创建了一些任务结构,但它们都处于“待命”状态,系统仍然在按传统的裸机前后台方式运行。调用这个函数后,FreeRTOS 内核会接管系统的控制权,开始根据优先级调度你创建的任务,多任务环境才真正开始。关键点:它没有参数。它的所有行为都由中的配置宏控制。它通常不会返回。一旦调用,除非没有任务可以运行(或者你显式地停止了调度器),否则程序流永远不会回到main()函数中调用它的下一行。是一个没有参数但行为由精密控制的函数。

Shylock_Mister的博客 1600

kotlin协程生命周期-基础

协程生命周期

且听真言 1419

Go-zero微服务实战:从零搭建电商用户系统(含完整代码示例)

本文详细介绍了如何使用go-zero框架从零搭建电商用户系统,包含完整的微服务架构设计、核心功能实现代码示例以及性能优化策略。通过分层架构设计、JWT认证、分布式锁等关键技术,实现高并发、高可用的用户系统,适用于电商平台开发。

weixin_29275257的博客 258

Openclaw 附录B 常用Skills清单

核心作用支持URL、网页、PDF、图片、音频和YouTube视频的摘要与字幕提取,由OpenClaw创始人@steipete开发的官方内置Skill。安装⚠️说明:原推荐的summarize未在ClawHub验证到,YouTube字幕提取功能已内置于summarize中。使用场景“提取这个2小时Next.js教程视频的核心代码逻辑,按章节整理成学习笔记”推荐指数:⭐⭐⭐⭐。

Maynor的博客 861

协程Coroutines入门

协程Coroutines入门

yinianzhijian99的专栏 3695

windows一键安装部署wvp-GB28181-pro视频监控平台

我们可以看到redis、mysql、zlm和wvp都正常运行了。该ip需要修改为wvp服务安装的 服务器的IP。默认用户名和密码分别为admin和admin。

zengliguang的专栏 5749

安卓coroutines 协程的简单使用

class MainActivity : AppCompatActivity() { private var mainScope = MainScope() override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) setContentView(R.layout.activity_main) test1() //

延成的博客 1002

[最新]MapReduce综合应用案例 — 气象数据清洗

【代码】[最新]MapReduce综合应用案例 — 气象数据清洗。

M_inherit的博客 1019

YOLO26改进105:全网首发--使用BiFPN改进特征金字塔网络

YOLOv6 v3.0在目标检测领域实现重大突破,通过改进网络架构和训练方案显著提升性能。该版本在COCO数据集上展现出优越表现:YOLOv6-N达到37.5% AP/1187 FPS,YOLOv6-S实现45.0% AP/484 FPS,均超越同类检测器。大模型YOLOv6-M/L分别达到50.0%/52.8% AP,L6版本更创下实时检测新纪录。关键技术包括RepVGGBlock、BiFusion等新型模块,通过多分支融合和高效重参数化设计提升性能。研究团队已验证各改进模块有效性,代码已开源。

AIcurator的博客 96

Android面试题之Kotlin 协程的挂起、执行和恢复过程

挂起点保存当前状态由管理。调度器控制挂起后的线程控制权交还。恢复条件满足时,调度器分配新线程,调用resumeWith方法恢复协程。调度器检查恢复环境,分配合适线程并调用resume方法继续执行。欢迎关注我的公众号查看更多精彩文章!

AntDream的程序世界 1329

CentOS7安装OpenSSL1.1.1s

CentOS7安装OpenSSL1.1.1s

Bertram的博客 735

GMP获取可以执行的协程的过程

因此,主要的流程是按照本地队列 → 全局队列 → 网络事件 → 窃取工作 → 空闲状态的顺序来寻找可执行的 Goroutine。时,会从全局队列尝试获取一个 Goroutine,这样可以确保公平性,避免两个 Goroutine 占据本地队列进行不停的互相复生。如果本地队列没有可执行的 Goroutine,且全局队列也为空,会检查是否有网络事件(如网络 I/O)。如果网络轮询已经初始化并且有等待事件,会尝试从网络事件中获取一个可执行的 Goroutine。如果成功,会返回一个 Goroutine。

xsh219的博客 461

IMSL CNL 7.0.0 (x86-64)Crack

IMSL CNL 7.0.0 (x86-64)Crack intel的算法库破解文件,这是C++版本的破解文件

win10 跳过U8环境检测的IE WebControls.rar

win10 安装u8的时候 提示IE WebControls 不通过,这个工具可以欺骗u8的检查。 跳过U8环境检测的IE WebControls。提示导入失败后,重新检测通过。

hello word(协程)的大致执行过程

----------helloword执行流程------== hello word 程序被编译成可执行文件加载到内存中 对于程序执行空间中的代码段,重要的是程序执行入口,不同平台执行入口不一样 在进行一系列的程序代码检查和初始化之后会已runtime.main为程序执行入口创建main goroutine main goutine 执行以后才会调用我们编写的main.main 数据段 全局变量 g0。m0 协程对应的数据结构是runtime.g,工作线程对应的是runtime.m,全局变量

a...Z 474

蓝牙模块HM-10手册

蓝牙模块HM-10手册,该手册对蓝牙模块HM-10进行了详细的介绍和使用方法以及一些AT指令。

4.协程-启动&分析执行过程

前面我们将 suspend 函数拔了个精光。让我们知道了 suspend 的功能,以及如何定义。经过前面的知识积累,我们接下来学习协程就很轻松了,打起精神!! runBlocking runBlocking 是什么呢?还记得我以前的代码如何写的吗? fun main() { GlobalScope.launch { delay(3000) print("开始执行") } Thread.currentThread().join() } 可以注意到上方的

u010194271的博客 571

jdk-8u144-linux-x64.tar.gz.

该资源为搭建Linux系统Java环境用,资源的后缀为tar.gz格式的压缩包

lua服务执行过程中协程的挂起和重新唤醒

lua服务在执行回调函数的过程中,调用某些函数会挂起协程,比如skynet.call, skynet.ret, skynet.response等等,这些函数把协程挂起后,如何唤醒呢?本文将对所有调用coroutine.yield的API的唤醒做下分析。(比较拗口,找不到更好的表达方式了)skynet.callfunction skynet.call(addr, typename, ...)

程书画的 BLOG 2707

python 异步生成器执行过程

【task1】-开始异步操作: 0,协程挂起2s。【task2】-开始异步操作: 0,协程挂起2s。【task3】-开始异步操作: 0,协程挂起2s。【task1】-开始异步操作: 1,协程挂起2s。【task2】协程处理继续: 即将进入下一个生成。【task2】-开始异步操作: 1,协程挂起2s。【task3】-开始异步操作: 1,协程挂起2s。【task1】-开始异步操作: 2,协程挂起2s。【task2】-开始异步操作: 2,协程挂起2s。【task3】-开始异步操作: 2,协程挂起2s。

bigear_yu的博客 929

Kotlin协程-async分析

本章讲解协程中asyncawait的原理。前提条件是知道父子协程是如何关联的,可以看这篇协程之间父子关系1-Job如何关联的了解。这里简单讲一下原理:使用await方法,这是一个挂载方法,协程执行到这里就会挂载(就是退出invokeSuspend方法),什么时候才能继续执行呢?使用await方法的协程会在这个协程的state链表中添加一个节点,当这个协程完成时,就会执行这个节点的invoke方法,就会唤醒之前挂载在这里的协程,顺便也把结果带回来了。在之前先看如下例子:你猜最后parentJob。

L25000的专栏 1545

go 执行curl_记一次 Go 协程泄漏的排查过程

昨天例行查看服务监控,发现协程数量异常增加(超过10倍)。经过一翻努力查到了源头,并顺利上线修复(效果见题图)。对于协程,一千个程序员有一千种用法。了解这次泄漏的细节意义并不大。但从发现到修复的整个过程还是有一些参考价值的,所以记录一下,分享给大家。首先想到的是最近有什么发版。结果发现我们是在10月28号有过发版,但问题是从30号开始的。对比了新上线的业务代码,没有发现可能导致泄漏的用法。这条线索...

weixin_33999969的博客 590

python异步协程async调用过程图解

项目中有用到协程,但是对于协程,线程,进程的区别还不是特别了解,所以用图示的方式画了出来,用于帮助理解。,可以是挂起多长时间,也可以是等待某个操作完成。挂起结束之后,协程变为可调用的状态,供事件循环调用。个人理解:(如果有问题,欢迎指正,目前循环事件如何确定执行哪个协程的这一块还没有研究)3)每次协程被调用之后,会一直执行直到下一次挂起(比如await),所以如果。图解如下:左边三列是协程,第四列是线程的占用情况,最右边是执行结果输出。所以写异步程序时候,需要确认是否有非常耗时的同步操作。

bigear_yu的博客 919

网络编程 - 协程介绍及基本示例

一、协程介绍及基本示例 手动切换(greenlet) from greenlet import greenletdef test1(): print (12) gr2.switch() print(34) gr2.switch() print (90)def test2(): print (56) gr1.switch() print...

weixin_34342578的博客 131

深入理解Python中的协程:创建与执行

通过本文的介绍,我们了解了Python中协程的基本概念、如何创建协程以及如何运行协程。协程是Python异步编程的重要组成部分,它能够帮助我们更好地处理I/O密集型任务,提高程序的性能和响应速度。在实际开发中,我们应该根据具体需求选择合适的编程模型,以实现更高效、更可靠的代码。👇热门内容👇python使用案例与应用_安城安的博客-优快云博客软硬件教学_安城安的博客-优快云博客Orbslam3&Vinsfusion_安城安的博客-优快云博客网络安全_安城安的博客-优快云博客。

anananajiushiwo的博客 654

libgo的协程调度分析

libgo1. libgo协程2. 调度器3. 协程执行器执行器对协程的调度4. 协程任务Task 1. libgo协程 libgo中的有调度器(scheduler) 和执行器(processer)的概念: 调度器主要用于创建执行器(支持动态扩展),对调度器而言,每个执行器是一个单独的线程,调度器做的最主要的工作,就是平衡各个执行器中的协程数量,防止饥饿效应,部分执行器过忙,部分执行器却没有task可执行,另外,如果某个执行器卡住,调度器也会将执行器中的可运行协程取出,放到负载最低的执行器上。 直接负责线

Birate的博客 1296

Unity3D 协程

简介 什么是协程? unity协程是一个能够暂停协程执行,暂停后立即返回主函数,执行主函数剩余的部分,直到中断指令完成后,从中断指令的下一行继续执行协程剩余的函数。函数体全部执行完成,协程结束。由于中断指令的出现,使得可以将一个函数分割到多个帧里去执行。 协程和线程的区别? 线程是利用多核达到真正的并行计算,缺点是会有大量的锁、切换、等待的问题,而协程是非抢占式,需要用户自己释放使用权来切换到其他协程, 因此同一时间其实只有一个协程拥有运行权, 相当于单线程的能力。 协...

Sakuya__的博客 1389

C++-一篇文章入门coroutines协程

本文介绍了C++协程的基本概念和实现原理。协程是可以暂停和恢复执行的函数,通过co_await/co_return关键字实现。编译器会将协程状态保存在堆上,并生成执行代码。文章通过一个最小示例展示了协程的执行流程:1)创建协程帧和promise对象;2)执行initial_suspend;3)遇到co_await时挂起;4)通过coroutine_handle恢复执行;5)最后调用final_suspend结束协程。协程的实现需要满足特定接口要求,包括promise_type和awaiter等组件。

mrbone11的博客 1282
上一篇: 协程-在使用过程需要了解一些内容
下一篇: 数据流-使用入门
mrRuby
博客等级 码龄11年 20粉丝 63原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值