coroutine

2020 年 4 月 20 日，Python 2 的最后一个版本 2.7.18 发布了，这意味着 Python 2 是真正的 EOL（end of life）了，一个时代终于落幕了。 Python 2.0 版本是在 2000 年发布的，至今正好到 20 周年（差半年），一代版本竟然持续了这么长时间。其中，2.7 版本是在 Python 3 推出后才发布的，它在 2010 年发布，至今已是 10 年之久。 这里还要注意： 不管你是为了Python就业还是兴趣爱好，记住：项目开发经验永远是核心，如果你没有2020最新python入门到高级实战视频教程，可以去小编的Python交流.裙 ：七衣衣九七七巴而五（数字的谐音）转换下可以找到了，里面很多新python教程项目，还可以跟老司机交流讨教！ 事实上，Python 诞生了 30 年，但版本演进过程一直很慢，目前最新发布的版本只到 3.8.2。 对比一下相差几岁的隔壁家选手，C++ 已经发展到了 20，JAVA 发展到了 14 ，PHP 到了 7.4，差距悬殊。 但是，版本发布太频繁，也不总是一件好事。就在 Python 程序员抱怨自己的 Python 2 项目还没升 3 版本时，有些 JAVA 程序员还在维护 6、7 版本的项目呢。版本迁移之苦，大家彼此彼此，五十步笑百步。 编程语言跨版本间出现不兼容的特性，几乎是常态。很多时候

python异步IO编程(一) 基础概念 协程： python generator与coroutine 异步IO （async IO）：一种由多种语言实现的与语言无关的范例（或模型）。 asyncio：Python 3.4版本引入的标准库，直接内置了对异步IO的支持。 异步IO 线程，多线程 多线程善于处理I/O密集型任务。 多进程擅长处理计算密集型（CPU-bound）任务：强密集循环和数学计算都属于此类。 并发是并行的一种特殊类型（或者说子类），多线程是并发的表现形式，多进程是并行的表现形式。 Python通过它的包 multiprocessing，threading 和 concurrent.futures 已经对这两种形式都提供了长期的支持。 异步IO 异步IO是一种单进程、单线程的设计：它使用协同多任务处理机制，是以协程为核心的一种编程模型。 异步IO并不是新发明的概念，它已经存在或正在被构建到其他语言及运行时环境中，如 Go，C# 和 Scala 等。 异步IO模型异步IO采用消息循环的模式，在消息循环中，主线程不断地重复“读取消息-处理消息”这一过程： loop = get_event_loop() // 实例消息队列 while True: event = loop.get_event() // 从队列中读取消息 process_event(event) /

【今日推荐】：为什么一到面试就懵逼！>>> 引自我在知乎上的回答： 进程 线程 协程 例程 过程 的区别是什么？ - 骏马金龙的回答 - 知乎 首先解释下程序、进程、上下文切换和线程。然后再解释协程、例程、过程。 程序 程序 ：源代码堆起来的东西。相当于一个一动不动没有生命的机器人。 虽然是没有生命的机器人，但是它被设计后就表示有了硬件，它的硬件决定了之后它有生命后是如何干活的 机器人有优劣，所以有些优秀的机器人干活很快，而有些机器人干活很慢 进程 进程 ：程序在系统上跑起来(运行)之后的东西(动态的)。相当于有了生命的机器人。生命是内核给的，动起来的能力是CPU提供的驱动力。 因为在操作系统看来，它已经有了生命，会赋予它一些属性，比如它叫什么(PID)，谁发明的(PPID)，它在哪个范围内活动(地址空间)................. 内核会记录这个机器人的信息 机器人可以造机器人(父子进程) 它可以中断或睡眠。比如机器人想充电，但是没电给它，它得等 内核可以跟它交流，比如传递一些数据给它、传递信号给它 它可以被毁掉。比如进程崩溃或正常退出或被信号终止 机器人毁掉后要为它收尸，如果机器人偷偷死掉，就会没人给它收尸而变成僵尸进程 严格地说，这个机器人运行起来之后虽然有了生命，但是没有灵魂，只有CPU给它驱动力的那一段时间，他才能动起来，其它时候都是在哪里睡觉 .......

【今日推荐】：为什么一到面试就懵逼！>>> 理解并发、并行的例子 先举例子来理解这2个概念的区别。 老师让两个同学去办公室谈话。如果这两同学(进程)是并列跨过办公室门(CPU)的，那么就是并行。如果同学A先进同学B后进入(或者先B后A)，或者两人并列同时进入，但是在办公室外的路人甲(用户)看来，同学A和同学B同时都在办公室内，这是并发。 其实这个例子不合理，因为真正的并行是多核CPU下的概念，但上面这个简单的例子非常有助于理解。 如果举例要精确一点，那么大概是这样的：进办公室有两个门(两CPU)，如果两同学分别从不同的门进入，不管先后性，两者互相独立，那么是并行；如果两同学不管以什么方式进入，在路人甲看来，他两同时都在办公室内，就是并发。 我不信到现在还不理解并发和并行。 并发和并行的理论性解释 为什么操作系统上可以同时运行多个程序而用户感觉不出来？ 这是因为无论是单CPU还是多CPU，操作系统都营造出了可以同时运行多个程序的 假象 。实际的过程操作系统对进程的调度以及CPU的快速上下文切换实现的： 每个进程执行一会就先停下来，然后CPU切换到下个被操作系统调度到的进程上使之运行 。因为切换的很快，使得用户认为操作系统一直在服务自己的程序。 再来解释并发就容易理解多了。 并发(concurrent)指的是多个程序可以同时运行的现象，更细化的是多进程可以同时运行或者多指令可以同时运行

##前言 本文将尝试详细的带大家一步步走完一个异步操作,从而了解tornado是如何实现异步io的. 其实本文是对 上一篇文 的实践和复习 主旨在于关注异步io的实现,所以会忽略掉代码中的一些异常处理.文字较多,凑合下吧 接下来只会贴出部分源码,帮助理解,希望有耐心的同学打开tornado源码,一起跟踪一遍吧. AsyncHTTPClient : AsyncHTTPClient 继承 Configurable ,从__new__重看出是单例模式. 根据 Configurable 的__new__和 AsyncHTTPClient 的 configurable_base 和 configurable_default 得知, 实例化后一定是 SimpleAsyncHTTPClient 的实例 fetch def fetch(self, request, callback=None, raise_error=True, **kwargs): if self._closed: raise RuntimeError("fetch() called on closed AsyncHTTPClient") if not isinstance(request, HTTPRequest): request = HTTPRequest(url=request, **kwargs) # We may

Coroutines build upon regular functions by adding two new operations. In addition to invoke (or call) and return, coroutines add suspend and resume. suspend — pause the execution of the current coroutine, saving all local variables resume — continue a suspended coroutine from the place it was paused you can only call suspend functions from other suspend functions, or by using a coroutine builder like launch to start a new coroutine. suspend函数只能在suspend函数中调用,或者在coroutine builder中. To specify where the coroutines should run, Kotlin provides three Dispatchers you can use for thread dispatch: +---

点击进入我的新博客 ###coroutine基础 Lua所支持的协程全称被称作协同式多线程（collaborative multithreading）。Lua为每个coroutine提供一个独立的运行线路。然而和多线程不同的地方就是，coroutine只有在显式调用yield函数后才被挂起，同一时间内只有一个协程正在运行。 Lua将它的协程函数都放进了coroutine这个表里，其中主要的函数如下 摘取一段 云风 的代码来详尽解释协程的工作机制，在这段代码中，展示了main thread和协程co之间的交互： <!-- lang: lua --> function foo(a) print("foo", a) return coroutine.yield(2 * a) end co = coroutine.create(function ( a, b ) print("co-body", a, b) local r = foo(a + 1) print("co-body", r) local r, s = coroutine.yield(a + b, a - b) print("co-body", r, s) return b, "end" end) print("main", coroutine.resume(co, 1, 10)) print("main", coroutine

小谈阻塞非阻塞 阻塞非阻塞概念都是对于线程, 进程这种粒度来说的, 因为只有他们才是内核有感知的, 协程是你内核无感知, 是你用户自己实现的. 例如在 Golang 中, resp, err := client.Do(req) 看着是阻塞的写法(有网络 IO), 但是 Go 的 Http 包是异步的, 这边在协程粒度是阻塞住了, 但是线程该干嘛就干嘛去了, 对于系统来说, 就是非阻塞. 应用程序觉得我遇到阻塞, 比如 I/O什么的, 我就 yield 出去, 把控制权交出去. 分清楚内核层和应用层是关键 阻塞还是非阻塞 应用程序的调用是否立即返回. 被挂起无法执行其他操作的则是阻塞型的, 可以被立即「抽离」去完成其他「任务」的则是非阻塞型的. 但是挂起就不能干事情了吗, 答案是否定的, 一个线程读文件,被阻塞了,资源会出让(陈力就列, 不能者止). coroutine也是, 但是比如 goroutine, go的调度器会把处于阻塞的的go程上的资源分配给其他go程. 但是这里的重点就是线程切换的代价比协程切换的代价高很多(线程切换涉及到内核态和用户态的切换) 协程线程 调度一个主动(协作式调度, 应用程序自己调度) 一个被动(抢占式调度, 操作系统调度) 异步和同步 数据 copy 时进程是否阻塞. 同步:应用层自己去想内核询问(轮询?); 异步:内核主动通知应用层数据. IO

协程 协程 协程 （ coroutine ）表示一种程序运行的方式，可以理解成 “ 协作的线程 ” 或 “ 协作的函数 ” 协程 既可以用单线程实现：是一种特殊的子例程；也可以用多线程实现：是一种 特殊的线程 协程与子例程的差异 传统的 “ 子例程 ”（ subroutine ）采用堆栈式 “ 后进先出 ” 的执行方式，只有当调用的子函数完全执行完毕，才会结束子函数的执行，并开始执行父函数。 协程 与其不同，多个线程（在单线程情况下是多个函数）可以井行执行，但只有一个线程（或函数）处于正在运行的状态，其他线程（或函数）都处于 暂停态 （ suspended ），线程（或函数）之间可以交换执行权 。也就是说，一个线程（或函数）执行到一半，可以暂停执行，将执行权交给另一个线程（或函数），等到后面收回执行权的时候，再恢复执行。这种可以并行执行、交换执行权的线程（或函数），就称为 协程 。 从实现上看，在内存中子例程只使用一个 栈 （ stack ），而 协程 是同时存在多个 栈 ，但只有一个 栈 是处在运行态。也就是说， 协程 是以多占用内存为代价实现多任务的并行运行 协程与普通线程的差异 function demo(){ console.log("demo start") setTimeout(function(){ ickt() },2000) console.log("demo

3 月，跳不动了？>>> Python中 yield 关键字的用途是什么？ 它有什么作用？ 例如，我试图理解这段代码 1 ： def _get_child_candidates(self, distance, min_dist, max_dist): if self._leftchild and distance - max_dist < self._median: yield self._leftchild if self._rightchild and distance + max_dist >= self._median: yield self._rightchild 这是呼叫者： result, candidates = [], [self] while candidates: node = candidates.pop() distance = node._get_dist(obj) if distance <= max_dist and distance >= min_dist: result.extend(node._values) candidates.extend(node._get_child_candidates(distance, min_dist, max_dist)) return result 调用 _get_child_candidates