一文学会Python协程

Python圣诞学习狂欢夜

距离开始还有3天

.

.

.

详情

.

.

.

生成器和协程的介绍

生成器(Generator)的本质和特点

生成器 是 可以生成一定序列的函数。 函数可以调用next()方法。

生成器的例子：

例子1: follow.py 可以使用生成器完成 tail -f 的功能，也就是跟踪输出的功能。

例子2： 生成器用作程序管道（类似unix pipe）

标注：unix管道一个uinx管道是由标准流链接在一起的一系列流程.

pipeline.py

理解pipeline.py

在pipeline中，follow函数和grep函数相当于程序链，这样就能链式处理程序。

Yield作为表达【我们开始说协程了~】

grep.py

yield最重要的问题在于yield的值是多少。

yield的值需要使用coroutine协程这个概念 相对于仅仅生成值，函数可以动态处理传送进去的值，而最后值通过yield返回。

协程的执行

协程的执行和生成器的执行很相似。当你初始化一个协程，不会返回任何东西。协程只能响应run和send函数。协程的执行依赖run和send函数。

协程启动

所有的协程都需要调用.next( )函数。调用的next( )函数将要执行到第一个yield表达式的位置。在yield表达式的位置上，很容易去执行就可以。协程使用next()启动。

使用协程的修饰器

由【协程启动】中我们知道，启动一个协程需要记得调用next( )来开始协程，而这个启动器容易忘记使用。使用修饰器包一层，来让我们启动协程。【以后所有的协程器都会先有@coroutine

关闭一个协程:

使用close()来关闭。

使用except捕获协程的关闭close():

grepclose.py

使用GeneratorExit这个异常类型

抛出一个异常：

在一个协程中，可以抛出一个异常

异常起源于yield表达式可以用常规方法去抓取

一些小tips

生成器不能够同时生成值和接受值

协程，管道，数据流

进程管道：如下图所示，一连串进程串起来像管道一样。

协程可以用来作为进程管道。 你仅仅需要把协程连接在一起，然后通过send()操作传递数据。 整个进程管道由三部分组成：

第一部分，管道源/协程源：

进程管道需要一个初始的源（一个生产者）。 这个初始的源驱动整个管道。 管道源不是协程。

第二部分，管道终止/协程终止：

管道必须有个终止点。 管道终止/协程终止是进程管道的终止点。

例子：以实现tail -f 功能为例子

分析：第一个follow函数是协程源，第二个printer函数是协程终止。协程源不是一个协程，但是需要传入一个已经初始化完毕的协程。在协程源当中，调用send()。

第三部分，管道过滤器:

叫过滤器其实并不贴切，应该叫中间人Intermediate：其两端都是send()函数。

(协程的中间层) 典型的中间层如下：

分析可知，中间层需要接受上一个coroutine，也需要往下一个coroutine里面传递值。

一个管道过滤器的例子从文章中找出具有“python”关键字的句子打印。 grep.py:

grep 从中间传入follow，然后printer传入grep。

协程和生成器的对比

不同处：生成器使用了迭代器拉取数据，协程使用send()压入数据。

变得多分支：（上一个协程发送数据去多个下一段协程）

图示：

使用协程，你可以发送数据 给多个协程过滤器/协程终了。但是请注意，协程源只是用来传递数据的，过多的在协程源中传递数据是令人困惑并且复杂的。

一个例子

从文章中分别打印出含有’python‘ ’ply‘ ’swig‘ 关键字的句子。使用了一个协程队列向所有printer协程 送出 接收到的数据。 图示：

或者这样Hook them up:

图示

为什么我们用协程

协程相较于迭代器，存在更加强大的数据路由（就像上图的数据流向）的可能。

协程可以将一系列简单的数据处理组件，整合到管道，分支，合并等复杂的布置当中。

但有些限制…【后文会说】相对于对象的优势

从概念上简单一点：协程就是一个函数，对象要构建整个对象。

从代码执行角度上来说，协程相对要快一些。

第三部分：协程，事件分发

事件处理

协程可以用在写各种各样处理事件流的组件。

介绍一个例子【这个例子会贯穿这个第三部分始终】要求做一个实时的公交车GPS位置监控。

编写程序的主要目的是处理一份文件。传统上，使用SAX进行处理。

【SAX处理可以减少内存空间的使用，但SAX事件驱动的特性会让它笨重和低效】

把SAX和协程组合在一起

我们可以使用协程分发SAX事件，比如：

解析：整个事件的处理如图所示

【最终的组合】

比如，把xml改成json最后从中筛选的出固定信息. buses.py

协程的一个有趣的事情是，您可以将初始数据源推送到低级别的语言，而不需要重写所有处理阶段。比如，PPT 中69-73页介绍的，可以通过协程和低级别的语言进行联动，从而达成非常好的优化效果。如Expat模块或者cxmlparse模块。ps: ElementTree具有快速的递增xml句法分析

第四部分：从数据处理到并发编程

复习一下上面学的特点：

协程有以下特点。

协程和生成器非常像。

我们可以用协程，去组合各种简单的小组件。

我们可以使用创建进程管道，数据流图的方法去处理数据。

你可以使用伴有复杂数据处理代码的协程。

一个相似的主题：

我们往协程内传送数据，向线程内传送数据，也向进程内传送数据。那么，协程自然很容易和线程和分布式系统联系起来。

基础的并发：

我们可以通过添加一个额外的层，从而封装协程进入线程或者子进程。这描绘了几个基本的概念。

目标！协程+线程【没有蛀牙】

下面看一个线程的例子。 cothread.py

例子解析：第一部分：先新建一个队列。然后定义一个永久循环的线程；这个线程可以将其中的元素拉出消息队列，然后发送到目标里面。第二部分：接受上面送来的元素，并通过队列，将他们传送进线程里面。其中用到了GeneratorExit ，使得线程可以正确的关闭。

Hook up：cothread.py

但是：添加线程让这个例子慢了50%

目标！协程+子进程

我们知道，进程之间是不共享系统资源的，所以要进行两个子进程之间的通信，我们需要通过一个文件桥接两个协程。

程序通过sendto()和recvfrom()传递文件。

和环境结合的协程：

使用协程，我们可以从一个任务的执行环境中剥离出他的实现。并且，协程就是那个实现。执行环境是你选择的线程，子进程，网络等。

需要注意的警告：

创建大量的协同程序，线程和进程可能是创建不可维护应用程序的一个好方法，并且会减慢你程序的速度。需要学习哪些是良好的使用协程的习惯。

在协程里send()方法需要被适当的同步。

如果你对已经正在执行了的协程使用send()方法，那么你的程序会发生崩溃。如：多个线程发送数据进入同一个协程。

同样的不能创造循环的协程：

堆栈发送正在构建一种调用堆栈（send()函数不返回，直到目标产生）。

如果调用一个正在发送进程的协程，将会抛出一个错误。

send() 函数不会挂起任何一个协程的执行。

第五部分：任务一样的协程

Task的概念

在并发编程中，通常将问题细分为“任务”。“任务”有下面几个经典的特点：* 拥有独立的控制流。* 拥有内在的状态。* 可以被安排规划/挂起/恢复。* 可与其他的任务通信。协程也是任务的一种。

协程是任务的一种：

下面的部分 来告诉你协程有他自己的控制流，这里 if 的控制就是控制流。

协程是一个类似任何其他Python函数的语句序列。

协程有他们内在的自己的状态，比如一些变量：其中的pattern和line就算是自己的状态。

本地的生存时间和协程的生存时间相同。

很多协程构建了一个可执行的环境。

协程可以互相通信，比如：yield就是用来接受传递的信息，而上一个协程的send( )就是用来向下一个协程。

7.协程可以被挂起，重启，关闭。

yield可以挂起执行进程。

send() 用来 重启执行进程。

close()用来终止/关闭进程。

总之，一个协程满足以上所有任务(task)的特点，所以协程非常像任务。但是协程不用与任何一个线程或者子进程绑定。

第六部分：操作系统的中断事件。（微嵌课程学的好的同学可以直接跳到这部分的“启示”）

操作系统的执行（复习微嵌知识）

当计算机运行时，电脑没有同时运行好几条指令的打算。而无论是处理器，应用程序都不懂多任务处理。所以，操作系统需要去完成多任务的调度。操作系统通过在多个任务中快速切换来实现多任务。

需要解决的问题（还在复习微嵌知识）

CPU执行的是应用程序，而不是你的操作系统，那没有被CPU执行的操作系统是怎么控制正在运行的应用程序中断的呢。

中断（interrupts）和陷阱（Traps）

操作系统只能通过两个机制去获得对应用程序的控制：中断和陷阱。* 中断：和硬件有关的balabala。* 陷阱：一个软件发出的信号。在两种状况下，CPU都会挂起正在做的，然后执行OS的代码（这个时候，OS的代码成功插入了应用程序的执行），此时，OS来切换了程序。

中断的底层实现（略…码字员微嵌只有70分‍）

中断的高级表现：

表现如下图：

每次中断（Traps）程序都会执行另一个不同的任务。

任务调度（非常简单）：

为了执行很多任务，添加一簇任务队列。

启示（很重要）：

BB了这么多微嵌的内容，得到的是什么结论呢。类比任务调度，协程中yield声明可以理解为中断（Traps）。当一个生成器函数碰到了yield声明，那函数将立即挂起。而执行被传给生成器函数运行的任何代码。如果你把yield声明看成了一个中断，那么你就可以组件一个多任务执行的操作系统了。

第七部分：让我们建一个操作系统。

目标：满足以下条件建成一个操作系统。

我们用python去构建操作系统的一些动机：

第一步：定义任务

定义一个任务类：任务像一个协程的壳，协程函数传入target；任务类仅仅有一个run()函数。pyos1.py

任务类的执行：

在foo中，yield就像中断（Traps）一样，每次执行run()，任务就会执行到下一个yield（一个中断）。

第二步：构建调度者

下面是调度者类，两个属性分别是Task队列和task_id与Task类对应的map。schedule()向队列里面添加Task。new()用来初始化目标函数（协程函数），将目标函数包装在Task，进而装入Scheduler。最后mainloop会从队列里面拉出task然后执行到task的target函数的yield为止，执行完以后再把task放回队列。这样下一次会从下一个yield开始执行。pyos2.py

下面是一个执行的例子：

执行结果，可以发现两个task之间任务是交替的，并且以yield作为中断点。每当执行撞到yield（中断点）之后，Scheduler对Tasks做重新的规划。下图是两个循环。上述执行的结果：

第三步：确定任务的停止条件

如果，target函数里面不是死循环，那么上面的代码就会出错。所以我们对Scheduler做改进。添加一个从任务队列中删除的操作，和对于StopIteration的验证。【对scheduler做改进的原因是任务的性质：可以被安排规划/挂起/恢复。】

第四步：添加系统调用基类。

在OS中，中断是应用程序请求系统服务的方式。在我们的代码中，OS是调度者（scheduler），而中断是yield。为了请求调度者服务，任务需要带值使用yield声明。 pyos4.py

代码解析：

如果taskmap里面存在task，就从ready队列里面拿任务出来，如果没有就结束mainloop。

【就是传说中的系统调运部分】ready队列里面的task被拿出来以后，执行task，返回一个result对象，并初始化这个result对象。如果队列里面的task要停止迭代了（终止yield这个过程）就从队列里删除这个任务。

最后再通过schedule函数把执行后的task放回队列里面。

系统调用基类，之后所有的系统调用都要从这个基类继承。

第4.5步：添加第一个系统调用

这个系统调用想返回任务的id。 Task的sendval属性就像一个系统调用的返回值。当task重新运行的是后，sendval将会传入这个系统调用。 pyos4.py

进行最后的调用：

理解这段代码的前提：（非常重要）

send()函数有返回值的，返回值是yield表达式右边的值。在本段代码中，result的返回值是yield GetTid()的GetTid的实例或者是yield后面的None。

.执行send(sendval)以后，sendval被传入了yield表达式。并赋给了mytid，返回GetTid()给ruselt。

执行顺序：先创建一个调度者(Scheduler)，然后在调度者里面添加两个协程函数：foo()， bar()，最后触发mainloop进行协程的调度执行。

系统调用原理：系统调用是基于系统调用类实现的，如GetTid类，其目的是传出自己的tid。传出自己的tid之后，再将task放回队列。

第五步：任务管理

上面我们搞定了一个GetTid系统调用。我们现在搞定更多的系统调用：* 创建一个新的任务。* 杀掉一个已经存在的任务。* 等待一个任务结束。这些细小的相同的操作会与线程，进程配合。

2. *杀掉一个系统调用*：通过系统调用杀掉一个task。

3. 进程等待：需要大幅度改进Scheduler。

exit_waiting 是用来暂时存放要退出task的地方。

设计讨论：

在任务中引用另一个任务的唯一办法 是 使用scheduler分配给它的任务ID。 上述准则是一个安全的封装策略。

这个准则让任务保持独立，不与内核混淆在一起。

这个准则能让所有的任务都被scheduler管理的好好的。

网络服务器的搭建：

但问题是这个网络服务器是I / O阻塞的。整个python的解释器需要挂起，一直到I/O操作结束。

非阻塞的I/O

先额外介绍一个叫Select的模块。select模块可以用来监视一组socket链接的活跃状态。

用法如下：

下面实现一个非阻塞I/O的网络服务器，所用的思想就是之前所实现的Task waiting 思想。

源码解析：

__init__里面的是两个字典。用来存储阻塞的IO的任务。waitforread()和waitforwrite()将需要等待写入和等待读取的task放在dict里面。这里的iopoll()：使用select()去决定使用哪个文件描述器，并且能够不阻塞任意一个和I/O才做有关系的任务。poll这个东西也可以放在mainloop里面，但是这样会带来线性的开销增长。

添加新的系统调用：

更多请见开头那个连接里面的代码：pyos8.py

这样我们就完成了一个多任务处理的OS。这个OS可以并发执行，可以创建、销毁、等待任务。任务可以进行I/O操作。并且最后我们实现了并发服务器。

第八部分：协程栈的一些问题的研究。

我们可能在使用yield的时候会遇到一些问题：

先来看一段示例代码：

这种情况下，server()函数里面的有调用Accept()，但是accept函数里面的yield不起作用。这是因为yield只能在函数栈的最顶层挂起一个协程。你也不能够把yield写进库函数里面。【这个限制是Stackless Python要解决的问题之一。

解决这个只能在函数栈顶挂起协程的解决方法。* 有且只有一种方法，能够创建可挂起的子协程和函数。* 但是，创建可挂起的子协程和函数需要通过我们之前所说的Task Scheduler本身。* 我们必须严格遵守yield声明。* 我们需要使用一种 -奇淫巧技- 叫做Trampolining（蹦床）。

让我们来看看这个叫蹦床的奇淫巧技。

代码：trampoline.py

整个控制流如下：

我们看到，上图中左侧为统一的scheduler，如果我们想调用一个子线程，我们都用通过上面的scheduler进行调度。

控制流：

控制过程：scheduler -> subroutine_1 -> scheduler -> subroutine_2 -> scheduler -> subroutine_1就像蹦床（trampolining）一样，所有的子进程调度都要先返回scheduler，再进行下一步。【有点像汽车换挡。

而不是：-scheduler -> subroutine_1 -> subroutine_2 -> subroutine_1-这种直接栈式的子协程调度是不被允许的。

第九部分：最后的一些话。

更加深远的一些话题。

有很多更加深远的话题值得我们去讨论。其实在上面的套路里面都说了一些。* 在task之间的通信。* 处理阻塞的一些操作：比如和数据库的一些链接。* 多进程的协程和多线程的协程。* 异常处理。

让我们对yield一点小尊重：

Python 的生成器比很多人想象的有用的多。生成器可以：

在下列三种蛀牙的情况下我们可以想起来，使用yield。

千万不要一个函数里面包含两个或多个以上的功能，比如函数是generator就是generator，是一个coroutine就是一个coroutin。

最后

感谢大家阅读

作者：xrtdkr

源自：https://juejin.im/post/5a37d5f66fb9a045146425e3

声明： 文章著作权归作者所有，如有侵权，请联系小编删除