Kotlin协程启动createCoroutine及创建startCoroutine原理

目录
  • createCoroutine 和 startCoroutine
    • startCoroutine调用
    • createCoroutineUnintercepted
    • intercepted
    • resume
  • 结语

createCoroutine 和 startCoroutine

协程到底是怎么创建和启动的?本篇文章带你揭晓。

在Continuation.kt文件中,有2个基础API,这里单独提出来说一下,方便后面我们理解launch。

public fun <T> (suspend () -> T).createCoroutine(
    completion: Continuation<T>
): Continuation<Unit> =
    SafeContinuation(createCoroutineUnintercepted(completion).intercepted(), COROUTINE_SUSPENDED)
public fun <T> (suspend () -> T).startCoroutine(
    completion: Continuation<T>
) {
    createCoroutineUnintercepted(completion).intercepted().resume(Unit)
}

createCoroutine和startCoroutine就是用来创建和启动协程的基础API,launch、async等在底层一定程度上都使用了该基础API,launch和async只不过是封装而已。所以,我们先掌握它们。

这2个函数看起来差别不大,一个调用了resume开始了协程,一个没有调用,需要外部去调用resume(createCoroutine会把Continuation返回出去)。

既然launch和async可以用它们来创建和启动协程,那我们是否可以直接用它们来创建和启动协程?那当然可以。这里我举个startCoroutine的例子,仔细看它的函数声明,它其实是个扩展函数,扩展的是(suspend () -> T)这种类型。

(suspend () -> T):suspend函数+返回类型是T

它可以有2种写法:

//方式1-----------
val block = suspend {
    ...
    "云天明"
}
block.startCoroutine(continuation)
//方式2--------------
suspend fun getUserName(): String {
    ...
    return "云天明"
}
(::getUserName).startCoroutine(continuation)

一种是匿名的suspend函数,一种是正常的有名字的suspend函数。现在,我们简单写个demo来调一下startCoroutine。

startCoroutine调用

//StartCoroutine.kt
fun main() {
    val continuation = object : Continuation<String> {
        override val context: CoroutineContext
            get() = EmptyCoroutineContext
        override fun resumeWith(result: Result<String>) {
            println("结果: ${result.getOrNull()}")
        }
    }
    block.startCoroutine(continuation)
    Thread.sleep(3000L)
}
val block = suspend {
    println("start")
    delay(2000L)
    println("end")
    "DX3906"
}

调起非常简单,startCoroutine是(suspend () -> T)的扩展函数,且需要传递一个Continuation参数。我们先反编译看一下,长什么样子。

public final class StartCoroutineKt {
    //block那块被转换成了一个类StartCoroutineKt$block$1,这里创建好一个实例对象,待会儿可以直接使用
    private static final Function1<Continuation<? super String>, Object> block = new StartCoroutineKt$block$1((Continuation<? super StartCoroutineKt$block$1>) null);
    public static final void main() {
        //调用扩展函数,将block和continuation参数传入。
        ContinuationKt.startCoroutine(block, new StartCoroutineKt$main$continuation$1());
        Thread.sleep(3000);
    }
    public static final Function1<Continuation<? super String>, Object> getBlock() {
        return block;
    }
}
//对应block那块
final class StartCoroutineKt$block$1 extends SuspendLambda implements Function1<Continuation<? super String>, Object> {
    int label;
    StartCoroutineKt$block$1(Continuation<? super StartCoroutineKt$block$1> continuation) {
        super(1, continuation);
    }
    //创建StartCoroutineKt$block$1实例
    public final Continuation<Unit> create(Continuation<?> continuation) {
        return new StartCoroutineKt$block$1(continuation);
    }
    public final Object invoke(Continuation<? super String> continuation) {
        //创建StartCoroutineKt$block$1实例并执行invokeSuspend
        return ((StartCoroutineKt$block$1) create(continuation)).invokeSuspend(Unit.INSTANCE);
    }
    public final Object invokeSuspend(Object $result) {
        Object coroutine_suspended = IntrinsicsKt.getCOROUTINE_SUSPENDED();
        //状态机
        switch (this.label) {
            case 0:
                //label一开始是0
                ResultKt.throwOnFailure($result);
                System.out.println("start");
                this.label = 1;
                //这里正常情况会返回COROUTINE_SUSPENDED,label已经改成1了,下次走case 1的逻辑
                if (DelayKt.delay(2000, this) != coroutine_suspended) {
                    break;
                } else {
                    return coroutine_suspended;
                }
            case 1:
                //label为1,没有return,继续走最后的结束语句
                ResultKt.throwOnFailure($result);
                break;
            default:
                throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
        }
        //结束
        System.out.println("end");
        return "云天明";
    }
}
//对应Continuation那块
public final class StartCoroutineKt$main$continuation$1 implements Continuation<String> {
    StartCoroutineKt$main$continuation$1() {
    }
    public CoroutineContext getContext() {
        return EmptyCoroutineContext.INSTANCE;
    }
    public void resumeWith(Object result) {
        //输出结果
        StringBuilder sb = new StringBuilder();
        sb.append("结果: ");
        sb.append((String) (Result.m29isFailureimpl(result) ? null : result));
        System.out.println(sb.toString());
    }
}

还是比较清晰的,

  • 首先object : Continuation<String> 是肯定会生成一个匿名内部类,在该类中,简单在resumeWith里面输出了一下结果
  • block那块代码,也会生成一个匿名内部类。需要注意的是,它继承自SuspendLambda,这个没见过,待会儿分析,里面有几个方法:create、invoke、invokeSuspend。其中create是创建该类的实例,invoke是调用create方法并执行invokeSuspend,invokeSuspend里面是状态机相关的逻辑。
  • main里面执行了ContinuationKt.startCoroutine(block, continuation),调起了扩展方法(扩展方法的原理就是这样的)

反编译出来的代码大致结构我们是了解了,现在需要分析一下startCoroutine具体是怎么走的了,看它是怎么利用这些反编译出来的代码的。

createCoroutineUnintercepted

public fun <T> (suspend () -> T).startCoroutine(
    completion: Continuation<T>
) {
    createCoroutineUnintercepted(completion).intercepted().resume(Unit)
}
//这个函数是expect的,没有函数体
public expect fun <T> (suspend () -> T).createCoroutineUnintercepted(
    completion: Continuation<T>
): Continuation<Unit>

startCoroutine首先是调用了createCoroutineUnintercepted函数,而createCoroutineUnintercepted是expect的,它是一种声明。因为Kotlin是跨平台的,所以部分逻辑与平台相关,这个createCoroutineUnintercepted就是这种。

它没有函数体,我们只关心JVM平台,所以需要到JVM平台上找该函数的实现。在Kotlin源码地图文章中,我们提到协程源码,分为2个仓库,一个是Kotlin仓库,一个是Kotlin协程仓库。

这个createCoroutineUnintercepted是在Kotlin仓库中,具体位置是:

kotlin/libraries/stdlib/jvm/src/kotlin/coroutines/intrinsics/IntrinsicsJvm.kt

public actual fun <T> (suspend () -> T).createCoroutineUnintercepted(
    completion: Continuation<T>
): Continuation<Unit> {
    val probeCompletion = probeCoroutineCreated(completion)
    return if (this is BaseContinuationImpl)
        //走这里
        create(probeCompletion)
    else
        createCoroutineFromSuspendFunction(probeCompletion) {
            (this as Function1<Continuation<T>, Any?>).invoke(it)
        }
}

咦,createCoroutineUnintercepted居然也是(suspend () -> T)的扩展函数,所以if那里的this指的就是block,也就是StartCoroutineKt$block$1。它继承自SuspendLambda。

internal abstract class SuspendLambda(
    public override val arity: Int,
    completion: Continuation<Any?>?
) : ContinuationImpl(completion), FunctionBase<Any?>, SuspendFunction {
    constructor(arity: Int) : this(arity, null)
    public override fun toString(): String =
        if (completion == null)
            Reflection.renderLambdaToString(this) // this is lambda
        else
            super.toString() // this is continuation
}
internal abstract class ContinuationImpl(
    completion: Continuation<Any?>?,
    private val _context: CoroutineContext?
) : BaseContinuationImpl(completion) {
    ......
}
//BaseContinuationImpl实现了Continuation接口
internal abstract class BaseContinuationImpl(
    public val completion: Continuation<Any?>?
) : Continuation<Any?>, CoroutineStackFrame, Serializable {
    ...
}

SuspendLambda是ContinuationImpl的子类,而ContinuationImpl是BaseContinuationImpl的子类。所以上面的if (this is BaseContinuationImpl)判断是ok的,会走到create(probeCompletion)

也就是StartCoroutineKt$block$1的create方法,在里面会创建StartCoroutineKt$block$1实例。

public final Continuation<Unit> create(Continuation<?> continuation) {
    return new StartCoroutineKt$block$1(continuation);
}

走到这里相当于startCoroutine中的createCoroutineUnintercepted(completion)这一步就走完了,它最终返回的是StartCoroutineKt$block$1的实例,也就是一个Continuation。它标志着协程被创建好了。再来看下intercepted是什么逻辑

intercepted

public fun <T> (suspend () -> T).startCoroutine(
    completion: Continuation<T>
) {
    createCoroutineUnintercepted(completion).intercepted().resume(Unit)
}
//好家伙,intercepted也是expect的
public expect fun <T> Continuation<T>.intercepted(): Continuation<T>

发现这里的intercepted扩展函数也是expect的,又得去kotlin仓库里面找jvm相关的实现。我找了下,路径在这里:

kotlin/libraries/stdlib/jvm/src/kotlin/coroutines/intrinsics/IntrinsicsJvm.kt

public actual fun <T> Continuation<T>.intercepted(): Continuation<T> =
    (this as? ContinuationImpl)?.intercepted() ?: this

intercepted是一个扩展函数,这里的this也就是前面createCoroutineUnintercepted(completion)创建出来的StartCoroutineKt$block$1实例,它本身是SuspendLambda的子类,而SuspendLambda就是ContinuationImpl的子类。

所以这里的as?会转换成功,转换出来的不是null。也就是说走到了ContinuationImpl的intercepted()

internal abstract class ContinuationImpl(
    completion: Continuation<Any?>?,
    private val _context: CoroutineContext?
) : BaseContinuationImpl(completion) {
    constructor(completion: Continuation<Any?>?) : this(completion, completion?.context)
    //这个context其实就是传入的Continuation中的context
    public override val context: CoroutineContext
        get() = _context!!
    @Transient
    private var intercepted: Continuation<Any?>? = null
    public fun intercepted(): Continuation<Any?> =
        intercepted
            ?: (context[ContinuationInterceptor]?.interceptContinuation(this) ?: this)
                .also { intercepted = it }
}
@Transient
private var intercepted: Continuation<Any?>? = null
public fun intercepted(): Continuation<Any?> =
        intercepted
            ?: (context[ContinuationInterceptor]?.interceptContinuation(this) ?: this)
                .also { intercepted = it }

第一次执行这里时intercepted是null,那么会从context中取ContinuationInterceptor,而context就是Continuation传入的context,我们传入的是EmptyCoroutineContext,取出来是null(ContinuationInterceptor会对Continuation进行拦截,然后将执行逻辑指派到对应的线程之上去,这块的逻辑后面再细说,就不详细展开了。)

所以这里intercepted()最终执行结果就是返回this,this也就是StartCoroutineKt$block$1(block函数生成的类)。

intercepted()走完后再回到startCoroutine:

public fun <T> (suspend () -> T).startCoroutine(
    completion: Continuation<T>
) {
    createCoroutineUnintercepted(completion).intercepted().resume(Unit)
}

resume

就差最后一个resume(Unit)了,前面createCoroutineUnintercepted(completion).intercepted()创建出来的是StartCoroutineKt$block$1实例,所以我们需要到这个类里面去找resume函数。

再提一下类的继承关系:

StartCoroutineKt$block$1 extends SuspendLambda implements Function1
internal abstract class SuspendLambda(
    public override val arity: Int,
    completion: Continuation<Any?>?
) : ContinuationImpl(completion), FunctionBase<Any?>, SuspendFunction
internal abstract class ContinuationImpl(
    completion: Continuation<Any?>?,
    private val _context: CoroutineContext?
) : BaseContinuationImpl(completion)
internal abstract class BaseContinuationImpl(
    public val completion: Continuation<Any?>?
) : Continuation<Any?>, CoroutineStackFrame, Serializable
public interface Continuation<in T> {
    public val context: CoroutineContext
    public fun resumeWith(result: Result<T>)
}

StartCoroutineKt$block$1中没有该resume函数,其父类SuspendLambda也没有该函数,再到SuspendLambda的父类ContinuationImpl中,发现也没有。再到ContinuationImpl的父类BaseContinuationImpl中,也没有该函数,只有一个resumeWith,奇了怪了。后来,我发现这个resume函数是一个扩展函数:

public inline fun <T> Continuation<T>.resume(value: T): Unit =
    resumeWith(Result.success(value))

而resume这个扩展函数最终是调用的resumeWith,resumeWidth的实现在BaseContinuationImpl中。

public final override fun resumeWith(result: Result<Any?>) {
    var current = this
    var param = result
    while (true) {
        probeCoroutineResumed(current)
        with(current) {
            val completion = completion!! // fail fast when trying to resume continuation without completion
            val outcome: Result<Any?> =
                try {
                    val outcome = invokeSuspend(param)
                    if (outcome === COROUTINE_SUSPENDED) return
                    Result.success(outcome)
                } catch (exception: Throwable) {
                    Result.failure(exception)
                }
            releaseIntercepted() // this state machine instance is terminating
            if (completion is BaseContinuationImpl) {
                current = completion
                param = outcome
            } else {
                //label等于1时走这里
                completion.resumeWith(outcome)
                return
            }
        }
    }
}

这个开了个while(true)循环,不断地执行invokeSuspend(),如果遇到invokeSuspend返回结果是COROUTINE_SUSPENDED则退出while(true)循环。

public final Object invokeSuspend(Object $result) {
    Object coroutine_suspended = IntrinsicsKt.getCOROUTINE_SUSPENDED();
    //状态机
    switch (this.label) {
        case 0:
            //label一开始是0
            ResultKt.throwOnFailure($result);
            System.out.println("start");
            this.label = 1;
            //这里正常情况会返回COROUTINE_SUSPENDED,label已经改成1了,下次走case 1的逻辑
            if (DelayKt.delay(2000, this) != coroutine_suspended) {
                break;
            } else {
                return coroutine_suspended;
            }
        case 1:
            //label为1,没有return,继续走最后的结束语句
            ResultKt.throwOnFailure($result);
            break;
        default:
            throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
    }
    //结束
    System.out.println("end");
    return "云天明";
}

invokeSuspend实际上就是我们的demo中的StartCoroutineKt$block$1里的invokeSuspend函数。在demo中,这个invokeSuspend第一次的时候状态机那里,label是0,所以会随即走到DelayKt.delay(2000, this),它是一个挂起函数,此时会拿到结果:COROUTINE_SUSPENDED

resumeWith遇到COROUTINE_SUSPENDED就不会继续往下走了,等到delay执行完成之后,会回调这个resumeWith函数,再继续走invokeSuspend,此时label已经是1了,走到状态机逻辑那里,返回结果“云天明”。

这个结果会被resumeWidth的outcome接收住,resumeWidth中的这个completion其实就是我们demo中的StartCoroutineKt$main$continuation$1(实现Continuation<String>的那个类,是通过构造函数传进来的),最终会走到completion.resumeWith(outcome),也就是来到了输出结果的地方:println("结果: ${result.getOrNull()}")。整个流程就走完了。

结语

createCoroutine用来创建协程,startCoroutine用来创建并启动协程。它们内部的原理是类似的,只是一个没有调用resume启动协程,另一个调用了resume启动协程。编译的时候,会生成一个SuspendLambda的实现类,该类invokeSuspend用于执行状态机的逻辑,调用resume后该状态机会被触发,状态机走完,协程也就走完了。

以上就是Kotlin协程启动createCoroutine及创建startCoroutine原理的详细内容,更多关于Kotlin协程启动创建的资料请关注我们其它相关文章!

(0)

相关推荐

  • Kotlin实现Android系统悬浮窗详解

    目录 Android 弹窗浅谈 系统悬浮窗具体实现 权限申请 代码设计 具体实现 FloatWindowService 类 FloatWindowManager 类 FloatWindowManager 类代码 FloatLayout 类及其 Layout HomeKeyObserverReceiver 类 FloatWindowUtils 类 总结 Android 弹窗浅谈 我们知道 Android 弹窗中,有一类弹窗会在应用之外也显示,这是因为他被申明成了系统弹窗,除此之外还有2类弹窗分别是

  • Kotlin协程Dispatchers原理示例详解

    目录 前置知识 demo startCoroutineCancellable intercepted()函数 DefaultScheduler中找dispatch函数 Runnable传入 Worker线程执行逻辑 小结 前置知识 Kotlin协程不是什么空中阁楼,Kotlin源代码会被编译成class字节码文件,最终会运行到虚拟机中.所以从本质上讲,Kotlin和Java是类似的,都是可以编译产生class的语言,但最终还是会受到虚拟机的限制,它们的代码最终会在虚拟机上的某个线程上被执行. 之

  • Kotlin协程launch原理详解

    目录 正文 launch使用 launch原理 CoroutineStart中找invoke方法 startCoroutineCancellable逻辑 小结 正文 launch我们经常用,今天来看看它是什么原理. 建议: 食用本篇文章之前记得先食用Kotlin协程之createCoroutine和startCoroutine launch使用 launch我们应该很熟悉了,随便举个例子: fun main() { val coroutineScope = CoroutineScope(Job(

  • java协程框架quasar和kotlin中的协程对比分析

    目录 前言 快速体验 添加依赖 添加javaagent 线程VS协程 协程代码 多线程代码 协程完胜 后记 前言 早就听说Go语言开发的服务不用任何架构优化,就可以轻松实现百万级别的qps.这得益于Go语言级别的协程的处理效率.协程不同于线程,线程是操作系统级别的资源,创建线程,调度线程,销毁线程都是重量级别的操作.而且线程的资源有限,在java中大量的不加限制的创建线程非常容易将系统搞垮.接下来要分享的这个开源项目,正是解决了在java中只能使用多线程模型开发高并发应用的窘境,使得java也能

  • kotlin源码结构层次详解

    目录 协程源码的结构 基础层 中间层 平台层 协程源码的结构 在研究Kotlin源码之前,得先搞懂Kotlin源码结构分布.不然找不到该看哪里的代码.看源码之前当然先得有一个目标,最好是带着这个目标去看源码才比较有针对性,抓主流程,不然可能会陷入浩瀚的源码细节中. 协程源码,按道理可以分成2个仓库,一个是Kotlin仓库,一个是Kotlin协程仓库. Kotlin仓库 https://github.com/JetBrains/kotlin 协程仓库 kotlinx.coroutines http

  • Kotlin与Java相互调用的完整实例

    目录 一.Kotlin 调用 Java 二.Java 调用 Kotlin 附 Github 源码: 总结 一.Kotlin 调用 Java 1. kotlin 关键字转义 java 中的方法或变量 是 kotlin 的关键字时,使用反引号 `` 对关键字进行转义 // java public class JavaDemo { String is; public String getIs() { return is; } public void setIs(String is) { this.is

  • 一篇文章揭开Kotlin协程的神秘面纱

    前言 Kotlin协程提供了一种新的异步执行方式,但直接查看库函数可能会有点混乱,本文中尝试揭开协程的神秘面纱. 理论 它是什么 这是别人翻译: 协程把异步编程放入库中来简化这类操作.程序逻辑在协程中顺序表述,而底层的库会将其转换为异步操作.库会将相关的用户代码打包成回调,订阅相关事件,调度其执行到不同的线程(甚至不同的机器),而代码依然想顺序执行那么简单. 我的理解:子任务程协作运行,优雅的处理异步问题解决方案. 它能干什么? 我在做安卓开发,它能替换掉Handler,AsyncTask 甚至

  • 使用kotlin协程提高app性能(译)

    协程是一种并发设计模式,您可以在Android上使用它来简化异步执行的代码.Kotlin1.3版本添加了 Coroutines,并基于其他语言的既定概念. 在Android上,协程有助于解决两个主要问题: 管理长时间运行的任务,否则可能会阻止主线程并导致应用冻结. 提供主安全性,或从主线程安全地调用网络或磁盘操作. 本主题描述了如何使用Kotlin协程解决这些问题,使您能够编写更清晰,更简洁的应用程序代码. 管理长时间运行的任务 在Android上,每个应用程序都有一个主线程来处理用户界面并管理

  • python 协程中的迭代器,生成器原理及应用实例详解

    本文实例讲述了python 协程中的迭代器,生成器原理及应用.分享给大家供大家参考,具体如下: 1.迭代器理解 迭代器: 迭代器是访问可迭代对象的工具 迭代器是指用iter(obj)函数返回的对象(实例) 迭代器是指用next(it)函数获取可迭代对象的数据 迭代器函数(iter和next) iter(iterable)从可迭代对象中返回一个迭代器,iterable必须是能提供一个迭代器的对象 next(iterator) 从迭代器iterator中获取下一了记录,如果无法获取下一条记录,则触发

  • 利用Kotlin的协程实现简单的异步加载详解

    前言 众所周知在android中当执行程序的耗时超过5秒时就会引发ANR而导致程序崩溃.由于UI的更新操作是在UI主线程进行的,理想状态下每秒展示60帧时人眼感受不到卡顿,1000ms/60帧,即每帧绘制时间不应超过16.67ms.如果某项操作的耗时超过这一数值就会导致UI卡顿.因此在实际的开发中我通常把耗时操作放在一个新的线程中(比如从网络获取数据,从SD卡读取图片等操作),但是呢在android中UI的更新只能在UI主线程中进行更新,因此当我们在非UI线程中执行某些操作的时候想要更新UI就需

  • Kotlin学习教程之协程Coroutine

    定义 Coroutine翻译为协程,Google翻译为协同程序,一般也称为轻量级线程,但需要注意的是线程是操作系统里的定义概念,而协程是程序语言实现的一套异步处理的方法. 在Kotlin文档中,Coroutine定义为一个可被挂起的计算实例,下面话不多说了,来一起看看详细的介绍吧. 配置 build.gradle中dependencies 添加下面2行,注意coroutine目前仍处于experiment阶段,但Kotline官方保证向前兼容. dependencies { implementa

  • 基于asyncio 异步协程框架实现收集B站直播弹幕

    前言 虽然标题是全站,但目前只做了等级 top 100 直播间的全天弹幕收集. 弹幕收集系统基于之前的B 站直播弹幕姬 Python 版修改而来.具体协议分析可以看上一篇文章. 直播弹幕协议是直接基于 TCP 协议,所以如果 B 站对类似我这种行为做反制措施,比较困难.应该有我不知道的技术手段来检测类似我这种恶意行为. 我试过同时连接 100 个房间,和连接单个房间 100 次的实验,都没有问题.>150 会被关闭链接. 直播间的选取 现在弹幕收集系统在选取直播间上比较简单,直接选取了等级 to

  • Python协程的用法和例子详解

    从句法上看,协程与生成器类似,都是定义体中包含 yield 关键字的函数.可是,在协程中, yield 通常出现在表达式的右边(例如, datum = yield),可以产出值,也可以不产出 -- 如果 yield 关键字后面没有表达式,那么生成器产出 None. 协程可能会从调用方接收数据,不过调用方把数据提供给协程使用的是 .send(datum) 方法,而不是next(-) 函数. ==yield 关键字甚至还可以不接收或传出数据.不管数据如何流动, yield 都是一种流程控制工具,使用

  • 老生常谈进程线程协程那些事儿

    一.进程与线程 1.进程 我们电脑的应用程序,都是进程,假设我们用的电脑是单核的,cpu同时只能执行一个进程.当程序出于I/O阻塞的时候,CPU如果和程序一起等待,那就太浪费了,cpu会去执行其他的程序,此时就涉及到切换,切换前要保存上一个程序运行的状态,才能恢复,所以就需要有个东西来记录这个东西,就可以引出进程的概念了. 进程就是一个程序在一个数据集上的一次动态执行过程.进程由程序,数据集,进程控制块三部分组成.程序用来描述进程哪些功能以及如何完成:数据集是程序执行过程中所使用的资源:进程控制

  • 深入浅析python中的多进程、多线程、协程

    进程与线程的历史 我们都知道计算机是由硬件和软件组成的.硬件中的CPU是计算机的核心,它承担计算机的所有任务. 操作系统是运行在硬件之上的软件,是计算机的管理者,它负责资源的管理和分配.任务的调度. 程序是运行在系统上的具有某种功能的软件,比如说浏览器,音乐播放器等. 每次执行程序的时候,都会完成一定的功能,比如说浏览器帮我们打开网页,为了保证其独立性,就需要一个专门的管理和控制执行程序的数据结构--进程控制块. 进程就是一个程序在一个数据集上的一次动态执行过程. 进程一般由程序.数据集.进程控

  • 为什么你还不懂得怎么使用Python协程

    前言 从语法上来看,协程和生成器类似,都是定义体中包含yield关键字的函数. yield在协程中的用法: 在协程中yield通常出现在表达式的右边,例如:datum = yield,可以产出值,也可以不产出--如果yield关键字后面没有表达式,那么生成器产出None. 协程可能从调用方接受数据,调用方是通过send(datum)的方式把数据提供给协程使用,而不是next(...)函数,通常调用方会把值推送给协程. 协程可以把控制器让给中心调度程序,从而激活其他的协程 所以总体上在协程中把yi

随机推荐

其他