协程-在使用过程需要了解一些内容

直击灵魂一问:协程到底是怎么切换线程的? 前置知识 CoroutineScope到底是什么? CoroutineScope即协程运行的作用域,它的源码很简单 public interface CoroutineScope { public val coroutineContext: CoroutineContext } 可以看出CoroutineScope的代码很简单,主要作用是提供CoroutineContext,协程运行的上下文 我们常见的实现有GlobalScope,LifecycleScope,ViewModelScop 阅读详情

前言

通过前一篇协程-Android端使用场景入门,了解协程的一些使用场景,为了能更高效的使用协程,我们还需要了解知识,这样才能在使用过程中得心应手。
为了能够更好的理解后面的内容,这里针对一些概念做统一的说明

(1)协程层级划分

image

  • CoroutineScope称为RootParent,同时也是parent
  • CoroutineScope启动的协程称为RootParent的child,同时协程里面又可以启动协程,此时该层也叫parent
  • 协程可以看做一种层级结构,统一概念是为了后面提到child或者parent的时候能够更好的明白

(2)协程生命周期

image

协程有上述的几种状态,其中的部分状态可通过Job进行访问,后续会进一步说明。

一、CoroutineScope

我们可以称为:协程作用域,就是对一个协程定义一个作用域,通过该作用域来启动或者控制协程的生命周期。在Android的KTX库中,已经提供了一些包含生命周期的CoroutineScope,viewModelScope和lifecycleScope,这两个的使用可以参考协程-Android端使用场景入门

同时我们也可以自己创建CoroutineScope,并在合适的时候控制它的生命的周期。如下所示:

//创建协程作用域
val scope = CoroutineScope(SupervisorJob() + Dispatchers.Main)

//创建协程-job是协程的句柄,可以控制该协程的生命周期,比如job.cancel()结束当前协程
val job = scope.launch{
    
}

//结束当前协程
job.cancle()

//结束整个CoroutineScope,通过scope.launch或者scope.async()创建的协程都会cancel
scope.cancel()

CoroutineScope创建很简单,传入一个CoroutineContext即可。下面是CoroutineScope的源码定义,

public interface CoroutineScope {
    public val coroutineContext: CoroutineContext
}

这个接口就只包含一个属性CoroutineContext,平时我们在开发使用到的都是CoroutineScope的扩展方法或者扩展属性。比如launch(),async(),cancel(),ensureActive()等,所以在创建CoroutineScope的时候,更重要的是关心CoroutineContenxt。下面一起来了解一下CoroutineContext。

二、CoroutineContext

协程的上下文,由不同的元素组成,分别定义协程的不同行为。包含以下元素:

  • Job - 控制协程的生命周期
  • CoroutineDispatcher - 将工作分配给合适的线程
  • CoroutineName - 协程的名字,调试的时候有用
  • CoroutineExceptionHandler - 处理未捕获的异常

当我们创建一个协程的时候,它的CoroutineContext是什么呢?可以是自己的父CoroutineScope的CoroutineContext,也可以是一个协程的CoroutineContext。如下:

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

val job = scope.launch {
    //该协程使用scope作为的父
    val result = async {
        // New coroutine that has the coroutine started by 
        // launch as a parent
    }.await()
}

三、协程生命周期

当我们通过scope.launch或者scope.async启动协程的时候,返回一个协程的Job句柄,通过它可以控制协程的生命周期,协程的生命周期如下图所示:

image
开发中,能够访问的属性有:isActive、isCancelled、isCompleted。

如果一个协程处于active状态,当失败或者调用job.cancel(),Job会进入Cancelling状态(isActive = false,isCancelled = true)。当所有协程的的工作完成后,进入Cancelled状态,isCompleted = true.

四、了解异常

在协程中,当出现异常的时候,会将异常传递到其父级,一般情况父级按下三种处理方式:

  1. 结束其所有的子协程
  2. 父级自己结束
  3. 向上一级传递

如下图所示:

image

这种情况下,异常会到协程的顶级RootParent,即CoroutineScope级,并且该CoroutineScope启动的协程都会被结束。

如果我们一个UI中使用scope启动多个协程,很显然不希望如果其中的一个协程抛出了异常,该scope所有的子协程都被取消,在这种场景下,可以使用SupervisorJob构建CoroutineContext。

五、SupervisorJob

5.1 概念

使用SupervisorJob,如果有一个子协程出错,不会影响其他的子协程.简单来讲就是不会影响CoroutineScope所启动的其他协程。如下图所示:
image

我们可以按以下方式使用SupervisorJob

val uiScope = CoroutineScope(SupervisorJob())

Android官方KTX库中的viewModelScope和lifeCycleScope都是使用的SupervisorJob,参代码如下:

public val ViewModel.viewModelScope: CoroutineScope
    get() {
        val scope: CoroutineScope? = this.getTag(JOB_KEY)
        if (scope != null) {
            return scope
        }
        return setTagIfAbsent(
            JOB_KEY,
            CloseableCoroutineScope(SupervisorJob() + Dispatchers.Main.immediate)
        )
    }


public val Lifecycle.coroutineScope: LifecycleCoroutineScope
    get() {
        while (true) {
            val existing = mInternalScopeRef.get() as LifecycleCoroutineScopeImpl?
            if (existing != null) {
                return existing
            }
            val newScope = LifecycleCoroutineScopeImpl(
                this,
                SupervisorJob() + Dispatchers.Main.immediate
            )
            if (mInternalScopeRef.compareAndSet(null, newScope)) {
                newScope.register()
                return newScope
            }
        }
    }

或者下面的方式:

val scope = CoroutineScope(SupervisorJob())
scope.launch {
    // Child 1
}
scope.launch {
    // Child 2
}
val scope = CoroutineScope(Job())
scope.launch {
    supervisorScope {
        launch {
            // Child 1
        }
        launch {
            // Child 2
        }
    }
}

注意:SupervisorJob需要放在CoroutineScope的CoroutineContext或者使用
supervisorScope才会生效。比如下面代码:

val scope = CoroutineScope(Job())
scope.launch(SupervisorJob()) {
    // new coroutine -> can suspend
   launch {
        // Child 1
    }
    launch {
        // Child 2
    }
}

在上面的片段代码中,Child1和Child2的job都是Job()而不是SupervisorJob()。如果其中的一个child出现未捕获的异常,那么该scope会被全部取消。

5.2 SupervisorJob和Job的异常验证

使用Job,代码如下:

    private val exceptionHandler = CoroutineExceptionHandler { coroutineContext, throwable ->
        println("Caught $throwable")
    }
    private fun fetchRemoteData() {
        throw Exception("fetch data error")
    }
    private fun testJob() {
        val scope = CoroutineScope(Job() + Dispatchers.IO)
        val job1 = scope.launch(exceptionHandler) {
            // child1
            fetchRemoteData()
        }
        val job2 = scope.launch {
            // child2
            delay(1000)
            println("this is child2 coroutine execute")
        }

    }

运行testJob方法,输出日志如下:

I/System.out: Caught java.lang.Exception: fetch data error

这里child2的println方法没有执行。下面我们修改创建scope的方法,将参数Job换成SupervisroJob()

    private fun testJob() {
        val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
        val job1 = scope.launch(exceptionHandler) {
            // child1
            fetchRemoteData()
        }
        val job2 = scope.launch {
            // child2
            delay(1000)
            println("this is child2 coroutine execute")
        }

    }

再次运行testJob(),日志如下:

 I/System.out: Caught java.lang.Exception: fetch data error
 I/System.out: this is child2 coroutine execute

这里我们看到child2执行了,经过上面的两次代码验证,得出Job和SupervisorJob的区别:

  • 使用SupervisorJob,如果有子协程抛出异常,协程不会向上传递,自己处理,也不影响scope以及其他子协程
  • 使用Job,如果有子协程抛出异常,父级结束所有子协程,父级自己结束,如果存在上一级,则继续线向上一级传递

六、协程中该如何处理异常

异常的处理和Kotlin的使用一样,使用try/catch或者CoroutineExceptionHandler

我们知道使用SupervisorJob和Job,内部对异常的处理方式不同,开发中我们用德比较多的是SuervisorJob,因此下面我们先了解SupevisroJob模式的异常处理。

而在协程中,不同的协程构建方式,对异常的处理有不同的方式。下面分别说明launch和async的方式

6.1 Launch

通过launch启动的协程,当出现异常时,异常会及时抛出。我们可以按照一下方式处理异常。

scope.launch {
    try {
        codeThatCanThrowExceptions()
    } catch(e: Exception) {
        // Handle exception
    }
}

6.2 Async

当使用async作为根协程(即:协程是CoroutineScope或者supervisorScope实例的直接子级),异常不会立即抛出,当调用await()方法使时才抛出。针对这种异常,我们对await()方法进行try/cathc即可:

supervisorScope {
    val deferred = async {
        codeThatCanThrowExceptions()
    }
    try {
        deferred.await()
    } catch(e: Exception) {
        // Handle exception thrown in async
    }
}

下面我们了解Job模式下的异常发生情况,如下代码:

    private fun testJob3() {
        val scope = CoroutineScope(Job() + Dispatchers.IO)

        scope.launch {
            try {
                val deferred = async {
                    fetchRemoteData()
                }
                deferred.await()
            } catch (ex: Exception) {
                //async中的异常不会到达这里,会向上传递
                ex.printStackTrace()
            }
        }
    }

运行该方法,你会发现,程序会崩溃,try/cathc并没有捕获到async中抛出的异常。因此使用Job方式,异常会直接向上一层级抛出。而向上一级抛出的异常,我们通过CoroutineContext中的CoroutineExceptionHandler来处理。如下所示:

    private val exceptionHandler = CoroutineExceptionHandler { coroutineContext, throwable ->
        println("Caught $throwable")
    }
    val scope = CoroutineScope(Job() + Dispatchers.IO)
    scope.launch(exceptionHandler) {
    val deferred = async {
        fetchRemoteData()
    }
    deferred.await()
    }
    //或者传递给scope的CouroutineContext
    val scope = CoroutineScope(Job() + Dispatchers.IO+exceptionHandler)
    scope.launch {
    val deferred = async {
        fetchRemoteData()
    }
    deferred.await()
    }

按照上面的方式,程序正常运行,因为我们通过我们CoroutineExceptionHandler处理了协程中未捕获的异常,

而下面的这种方式是不能处理未捕获的异常的:

    private fun testJob3() {
        val scope = CoroutineScope(Job() + Dispatchers.IO)
        scope.launch {
            launch(exceptionHandler) {
                fetchRemoteData()
            }
        }
    }

这里异常就未能被捕获处理,因为job()类型的异常向上传递后,没有在对应的CoroutineContext中找到对应的exceptionHandler

七、Cancel coroutine 取消协程

当我们启动多个协程时,可以通过协程作用域(scope)来取消他们:

val job1 = scope.launch{ ...... }
val job2 = scope.launch{ ...... }

//取消该scope下的所有协程
scope.cancel()

某些情况下我们想取消其中的一个协程,可进行如下操作:

val job1 = scope.launch{ ...... }
val job2 = scope.launch{ ...... }

//取消job1
job1.cancel()

注意:这里取消子协程需要留意Job()或者SuperiseJob()下的不同。如果调用了scope.cancel(),那么该scope将不能启动新的协程。

在androidx 的KTX扩展库中,我们可以根据具体的需求来选择使用viewModelScope或者LifecycleScope,这两个scope都会在合适的时机来结束scope。比如viewModleScope会在ViewModel的clear()方法中取消对应的scope.

7.1 cancle后协程会立即结束吗?

如果我们仅仅调用cacel()方法,并不意味着协程的工作会立即结束。比如下面的例子:

    private fun testCancel() {
        val scope = CoroutineScope(Job() + Dispatchers.IO)
        val job = scope.launch {
            val startTime = System.currentTimeMillis()
            var nextPrintTime = startTime
            var i = 0
            while (i < 5) {
                if (System.currentTimeMillis() >= nextPrintTime) {
                    println("hello ${i++}")
                    nextPrintTime += 500
                }
            }
        }
        scope.launch {
            delay(1000)
            println("start cancel")
            job.cancel()
        }
    }

上面程序每隔500毫秒打印一次,那么调用1秒过后调用job.cancel(),启动的协程还会继续打印吗?

运行我们的程序,结果如下:

 2100-2136/com.persson.myapplication I/System.out: hello 0
 2100-2136/com.persson.myapplication I/System.out: hello 1
 2100-2136/com.persson.myapplication I/System.out: hello 2
 2100-2138/com.persson.myapplication I/System.out: start cancel
 2100-2136/com.persson.myapplication I/System.out: hello 3
 2100-2136/com.persson.myapplication I/System.out: hello 4

当调用job.cancle()后,协程进入Cancelling状态,但协程会继续运行,打印hello 3和hello 4,当所有协程的工作完成后,协程进入Cancelled状态。

7.2 如何正确的停止协程的工作

在上述的示例中,为了保证cancel后协程能够停止所有的工作,以及进入canceld状态,我们可以在循环中使用job.isActive或者ensureActivie()判断
如下:

    private fun testCancel() {
        val scope = CoroutineScope(Job() + Dispatchers.IO)
        val job = scope.launch {
            ...
            var i = 0
            while (i < 5 && isActive) {
               ...
            }
        }
        ...
    }
    //或
    private fun testCancel() {
    val scope = CoroutineScope(Job() + Dispatchers.IO)
    val job = scope.launch {
        ...
        var i = 0
        while (i < 5 &&) {
            ensureActive()
           ...
        }
    }
    ...
}
    

运行结果如下:

 2100-2136/com.persson.myapplication I/System.out: hello 0
 2100-2136/com.persson.myapplication I/System.out: hello 1
 2100-2136/com.persson.myapplication I/System.out: hello 2
 2100-2138/com.persson.myapplication I/System.out: start cancel

最后

上面这些内容介绍协程在使用中的一些注意事项,主要分为以下内容:

  1. CroutineScope和CoutineConext的作用
  2. Job和SupervisorJob的区别
  3. 在不同模式下如何正确的处理协程异常
  4. 如何有效的停止协程工作

参考资料:

https://medium.com/androiddevelopers/coroutines-first-things-first-e6187bf3bb21

https://medium.com/androiddevelopers/cancellation-in-coroutines-aa6b90163629

https://medium.com/androiddevelopers/exceptions-in-coroutines-ce8da1ec060c

QT 界面编程中使用协程 主要介绍在Windows平台下如何在界面编程中使用协程模块,达到协程与界面编程的无缝衔接。 阅读详情

相关推荐

Kotlin协程使用

​​) {​test1()​​return "网络数据..."​Log.i("cyc", "请求网络IO")Log.i("cyc", "逻辑处理")​​​flow {emit(0).flowOn(Dispatchers.IO)//作用于flow代码块.collect {​​​。

weixin_39971470的博客 2065

kotlin协程相关类之间的关系

一、相关类图 弄清协程一些类和接口的关系,有助于大家整体对协程的理解 二、相关类概述 协程作用域 协程上下文 协程的分发器 协程的构建器 Job 协程和线程的关系 三、相关类之间的关系 通过一个简单的示例简述上面相关类的关系 一个协程作用域,以CoroutineSope为例,包含了一个协程的上下文CoroutineContext, 协程fen ...

ydjjcdd的博客 447

简单了解线程和协程(C#)

简单了解线程和协程(C#)

falsedewuxin的博客 5451

协程的用法

协程的用法

weixin_66398100的博客 708

Golang中协程的使用

原文链接: https://www.ahaoaha.top/2019/05/09/Golang中协程的使用/ 本文相关demo,请点击此处 协程与函数返回值 golang中的协程是由Go routime进行管理的,如果函数有返回值,则这个函数的返回值会被丢弃。 Golang协程的创建 使用go FUNC_NAME(PARAMETER_LIIST)可以很简单的创建出一个协程来执行相应的操作 Gola...

h___q的博客 1855

信创那些事儿——Spring Boot中集成东方通中间件(TongWeb)

在Spring Boot中集成东方通中间件(如TongWeb作为Servlet容器)通常涉及几个步骤,但需要注意的是,TongWeb本身是一个独立的Java EE应用服务器,而不是像Tomcat那样可以直接嵌入到Spring Boot应用中的中间件。因此,集成通常意味着将Spring Boot应用打包为WAR文件并部署到TongWeb服务器上。

来北欧写代码 6496

Kotlin协程 - - - 协程的简单使用

一.协程介绍 1.简介 协程是一种并发设计模式,您可以在 Android 平台上使用它来简化异步执行的代码。协程是在版本 1.3 中添加到 Kotlin 的,它基于来自其他语言的既定概念。 在 Android 上,协程有助于管理长时间运行的任务,如果管理不当,这些任务可能会阻塞主线程并导致应用无响应。使用协程的专业开发者中有超过 50% 的人反映使用协程提高了工作效率。本主题介绍如何使用 Kotlin 协程解决以下问题,从而让您能够编写出更清晰、更简洁的应用代码。 2.特点 协程是我们...

m0_47914176的博客 4900

从零开始掌握Python机器学习:七步教程 基础篇

前言 「开始」往往是最难的,尤其是当选择太多的时候,一个人往往很难下定决定做出选择。本教程的目的是帮助几乎没有 Python 机器学习背景的新手成长为知识渊博的实践者,而且这个过程中仅需要使用免费的材料和资源即可。 第一步:基本 Python 技能 如果我们打算利用 Python 来执行机器学习,那么对 Python 有一些基本的了解就是至关重要的。 首先,你需要安装 Python。因为我们后...

hcgx2018的博客 1617

【八】并发编程之异步编程

【八】并发编程之异步编程 异步编程 基于 async 和 await 关键字的协程可以实现异步编程,这也是目前 Python 异步相关的主流技术。在这里我们主要介绍一下实现异步的模块:asyncio 模块 【一】asyncio 模块 asyncio 模块是 Python 中实现异步的一个模块,该模块在 Python3.4 的时候发布,async 和 await 关键字在 Python3....

Chimengmeng的博客 415

【教培管家】小程序实战(五):体验课预约——从流量到转化的闭环

本节我们通过变量状态管理和数据联动,实现了孩子选择和日期选定。下一篇我们继续讲解预约页面,根据选择的日期来筛选排课,供用户进行预约。

低代码布道师的博客 1563

NR PUCCH(二)PUCCH format 2/3/4

继续看PUCCH2/3/4:PUCCH format 0和1所携带的信息bits少,UCI bits2bits,信息bit需要经过编码等过程下面分别来看。

ModemProtocol的博客 539

Kotlin协程:协程的基础与使用

协程是Coroutine的中文简称,co表示协同、协作,routine表示程序。协程可以理解为多个互相协作的程序。协程是轻量级的线程,它的轻量体现在启动和切换,协程的启动不需要申请额外的堆栈空间;协程的切换发生在用户态,而非内核态,避免了复杂的系统调用。...

LeeDuoZuiShuai的博客 1万+

YOLOv8独家原创改进:原创自研 | 创新自研CPMS注意力,多尺度通道注意力具+多尺度深度可分离卷积空间注意力,全面升级CBAM

自研CPMS,多尺度通道注意力具+多尺度深度可分离卷积空间注意力,全面升级CBAM

①答疑群聊服务;②YOLO大模型知识问答系统;③计算机视觉论文生成智能体; 3800

协程的概念,为什么要用协程,以及协程的使用

什么是协程 协程, 又称为微线程,是一种用户态的轻量级线程。协程不像线程和进程那样,需要进行系统内核上的上下文切换,协程的上下文切换是由开发人员决定的。 协程是一种用户级的轻量级线程。协程拥有自己的寄存器上下文和栈。协程调度切换时,将寄存器上下文和栈保存到其他地方,在切回来的时候,恢复先前保存的寄存器上下文和栈。因此: 协程能保留上一次调用时的状态(即所有局部状态的一个特定组合),每次过程重入时,...

weixin_44575037的博客 2万+

Coze智能体开发:开始使用扣子

扣子全新升级!它不仅能帮你办公、做视频、写代码,更具备自主任务执行、探索进化等能力,真正从“陪你聊”走向“帮你干活”。

王国平的博客 127

基于 STM32 的智能水表流量计设计与实现 —— 数据采集与远程传输

本文设计的基于 STM32 的智能水表流量计通过霍尔传感器实现流量采集,结合 STM32 的处理能力完成数据计算、存储与远程传输,具备计量精准、功耗低、可远程监控等特点。未来可优化方向:引入低功耗模式延长电池寿命,增加水质检测模块实现多参数监测,提升水务管理智能化水平。

weixin_42300449的博客 1031

Kotlin协程的使用

目录 引入kotlin协程 kotlin协程的三种启动方式 初识协程: 第一种启动方式(runBlocking:T) 第二种启动方式(launch:Job) 第三种启动方式(async/await:Deferred) 实现你的第一个Coroutine程序 浅析Kotlin协程 ——协程是什么?https://blog.csdn.net/qq_17798399/article/det...

青冘的技术学习博客 1万+

【异常】Cursor报错We‘re having trouble connecting to the model provider. This might be temporary

在使用Cursor编辑器进行AI交互操作时,界面弹出如下报错提示,导致无法正常调用模型服务,影响使用流程:We’re having trouble connecting to the model provider. This might be temporary - please try again in a moment. 该报错核心含义为Cursor编辑器无法正常连接至背后的AI模型服务提供商(如OpenAI、Anthropic等),属于连接类异常,并非编辑器本身运行故障。经排查,该报错不具备破坏性,仅

奶爸的编程之路,也就一周冷个三天 1695

python协程使用场景_听说你对协程不太了解

​python 一直在进行并发编程的优化, 比较熟知的是使用 thread 模块多线程和 multiprocessing 多进程,后来慢慢引入基于 yield 关键字的协程。而近几个版本,python 对于协程的写法进行了大幅的优化,很多之前的协程写法不被官方推荐了。协程发展历程Python中的协程大概经历了如下三个阶段:最初的生成器变形yield/sendyield from在Python3.5...

weixin_39537680的博客 817

OV9734 DATASHEET,完整规格书

OV9734完整规格书,包括电气参数,尺寸规格,寄存器配置表等

VC中sqlite的使用

在VC中对sqlite的使用,实现数据库大批数据的快速插入,读取数据库中的数据在ListCtrl中显示

Kotlin 协程(一)协程的定义及基础使用

Kotlin 协程是一种轻量级的并发编程方式,用于简化异步代码的编写。它允许你编写看似同步的代码来处理异步任务,使代码更加简洁、可读且易于维护。协程广泛应用于 Android 开发中,用于网络请求、数据库操作等需要异步执行的任务。协程是一种语法糖 协程的出现是来解决异步问题的,但它本身却不提供异步的能力,协程某种意义上更像是一种语法糖,它为我们隐藏了异步调用和回调的细节,让我们更关注于业务逻辑的实现。一句话概括,协程是一种轻量级的方便操作异步代码的语法糖,而它本身不提供异步能力。

Android 领域开发程序员,希望通过写博客的方式不断的总结提升自己,大家共同进步哦! 1536

C# WinForm 基于DirectShow.dll编写的程序,可边预览边保存视频,音频和图片

基于微软的DirectShow.dll的二次开发1.自动识别连接的摄像头跟麦克风且可以对其进行选择(默认选中第一个)2.可录制wmv和avi两种格式的视频并且都带有音频,avi可以录制的分辨率和帧数进行选择,wmv默认进行了淸晰度优化如不喜欢可去除代码中有相关提示3.可在预览点开之后进行拍照,也可边录制视频边拍照4.添加了视频和音频的压缩功能(酌情使用)这次二次开发发现C#对DirectShow的相关信息太少,这次做完也不敢藏私共享出来,还望大家指正

协程基础了解

目录 一.概念 协程是啥 协程和线程差异 二.协程介绍 三.Greenlet模块 四.Gevent模块 一.概念 之前我们学习了线程、进程的概念,了解了在操作系统中进程是资源分配的最小单位,线程是CPU调度的最小单位。按道理来说我们已经算是把cpu的利用率提高很多了。但是我们知道无论是创建多进程还是创建多线程来解决问题,都要消耗一定的时间来创建进程、创建线程、以及管理他们之间的切换。 随着我们对于效率的追求不断提高,基于单线程来实现并发又成为一个新的课题,即只用一个主 线程(.

jcf52的博客 765

IDEA的使用指南

IDEA基于java的使用手册,可以最快速的上手,在使用中不断的丰富自己的使用技巧.

超长文,带你全面了解Kotlin的协程

/ 今日科技快讯 /工信部近日发布了2019年1-11月通信业经济运行情况。数据显示,截至11月底,三家基础电信企业的移动电话用户总数达16亿户,同比增长2.7%,较上年末净增3...

郭霖 2818

了解Kotlin协程实现原理

协程只是编程历史发展过程中产生的对开发者友好的一种异步编程方式,相对于传统的多线程并发编程并不能提高额外的性能,协程并发编程的底层仍是用线程池实现,因为耗时的操作总要线程去执行,协程并不能减少额外的执行逻辑,另外协程因为创建了中间的一系列封装对象,比传统的多线程编程增加了额外的内存消耗,官方文档对此特定说明了编译器会进行一些优化,从而尽可能减少内存消耗,开发者无需担心,但协程所带来的开发维护成本大大减低、内存上的妥协带来的是对开发者的友好还是值得的。总结一下协程的优势简洁。

chuyouyinghe的专栏 728

Kotlin协程-async分析

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

L25000的专栏 1545

一篇文章了解Python中的协程、例子、协程的发展

网上关于Python的协程知识较乱,很多文章说法不一样,遂查原始的资料,再总结一下。 内容: 认识协程 1、一些基本概念 2、协程的特点 Python的协程 1、Python2的yeild和send实现协程 2、Python的gevent协程框架 3、Python3的asyncio协程框架 一、协程基本概念: 协程(英语:coroutine)是一种计算机程序组件,它通过允许多个入口点在特定位置暂停和恢复执行,从而为非抢占的多任务...

巴山夜雨 754
上一篇: 协程-Android端使用场景入门
下一篇: 协程-执行过程
mrRuby
博客等级 码龄11年 20粉丝 63原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值