首页 > 代码库 > python之协程与IO操作
python之协程与IO操作
协程
协程，又称微线程，纤程。英文名Coroutine。
协程的概念很早就提出来了，但直到最近几年才在某些语言（如Lua）中得到广泛应用。
子程序，或者称为函数，在所有语言中都是层级调用，比如A调用B，B在执行过程中又调用了C，C执行完毕返回，B执行完毕返回，最后是A执行完毕。
所以子程序调用是通过栈实现的，一个线程就是执行一个子程序。
子程序调用总是一个入口，一次返回，调用顺序是明确的。而协程的调用和子程序不同。
协程看上去也是子程序，但执行过程中，在子程序内部可中断，然后转而执行别的子程序，在适当的时候再返回来接着执行。
线程和进程的操作是由程序触发系统接口，最后的执行者是系统；协程的操作则是程序员。
协程可以被认为是一种用户空间线程，与传统的抢占式线程相比，有2个主要的优点：
- 与线程不同，协程是自己主动让出CPU，并交付他期望的下一个协程运行，而不是在任何时候都有可能被系统调度打断。因此协程的使用更加清晰易懂，并且多数情况下不需要锁机制。
- 与线程相比，协程的切换由程序控制，发生在用户空间而非内核空间，因此切换的代价非常的小。
- 某种意义上，协程与线程的关系类似与线程与进程的关系，多个协程会在同一个线程的上下文之中运行。
协程存在的意义：对于多线程应用，CPU通过切片的方式来切换线程间的执行，线程切换时需要耗时（保存状态，下次继续）。协程，则只使用一个线程，在一个线程中规定某个代码块执行顺序。
协程的适用场景：当程序中存在大量不需要CPU的操作时（IO），适用于协程；
协程的好处：
- 无需线程上下文切换的开销
- 无需原子操作锁定及同步的开销
- "原子操作(atomic operation)是不需要synchronized"，所谓原子操作是指不会被线程调度机制打断的操作；这种操作一旦开始，就一直运行到结束，中间不会有任何 context switch （切换到另一个线程）。原子操作可以是一个步骤，也可以是多个操作步骤，但是其顺序是不可以被打乱，或者切割掉只执行部分。视作整体是原子性的核心。
- 方便切换控制流，简化编程模型
- 高并发+高扩展性+低成本：一个CPU支持上万的协程都不是问题。所以很适合用于高并发处理。
缺点：
- 无法利用多核资源：协程的本质是个单线程,它不能同时将 单个CPU 的多个核用上,协程需要和进程配合才能运行在多CPU上.当然我们日常所编写的绝大部分应用都没有这个必要，除非是cpu密集型应用。
- 进行阻塞（Blocking）操作（如IO时）会阻塞掉整个程序
进程、线程和协程的区别
进程：
进程之间不共享任何状态，进程的调度由操作系统完成，每个进程都有自己独立的内存空间，进程间通讯主要是通过信号传递的方式来实现的，实现方式有多种，信号量、管道、事件等，任何一种方式的通讯效率都需要过内核，导致通讯效率比较低。由于是独立的内存空间，上下文切换的时候需要保存先调用栈的信息、cpu各寄存器的信息、虚拟内存、以及打开的相关句柄等信息，所以导致上下文进程间切换开销很大，通讯麻烦。
线程：
线程之间共享变量，解决了通讯麻烦的问题，但是对于变量的访问需要锁，线程的调度主要也是有操作系统完成，一个进程可以拥有多个线程，但是其中每个线程会共享父进程像操作系统申请资源，这个包括虚拟内存、文件等，由于是共享资源，所以创建线程所需要的系统资源占用比进程小很多，相应的可创建的线程数量也变得相对多很多。线程时间的通讯除了可以使用进程之间通讯的方式以外还可以通过共享内存的方式进行通信，所以这个速度比通过内核要快很多。另外在调度方面也是由于内存是共享的，所以上下文切换的时候需要保存的东西就像对少一些，这样一来上下文的切换也变得高效。
协程：
协程的调度完全由用户控制，一个线程可以有多个协程，用户创建了几个线程，然后每个线程都是循环按照指定的任务清单顺序完成不同的任务，当任务被堵塞的时候执行下一个任务，当恢复的时候再回来执行这个任务，任务之间的切换只需要保存每个任务的上下文内容，就像直接操作栈一样的，这样就完全没有内核切换的开销，可以不加锁的访问全局变量，所以上下文的切换非常快；另外协程还需要保证是非堵塞的且没有相互依赖，协程基本上不能同步通讯，多采用一步的消息通讯，效率比较高。
网络编程模型
我们首先来简单回顾一下一些常用的网络编程模型。网络编程模型可以大体的分为同步模型和异步模型两类。
- 同步模型：
同步模型使用阻塞IO模式,在阻塞IO模式下调用read等IO函数时会阻塞线程直到IO完成或失败。 同步模型的典型代表是thread_per_connection模型，每当阻塞在主线程上的accept调用返回时则创建一个新的线程去服务于新的socket的读/写。这种模型的优点是程序逻辑简洁，符合人的思维；缺点是可伸缩性收到线程数的限制，当连接越来越多时，线程也越来越多，频繁的线程切换会严重拖累性能，同时不得不处理多线程同步的问题。
- 异步模型：
异步模型一般使用非阻塞IO模式，并配合epoll/select/poll等多路复用机制。在非阻塞模式下调用read，如果没有数据可读则立即返回，并通知用户没有可读（EAGAIN/EWOULDBLOCK），而非阻塞当前线程。异步模型可以使一个线程同时服务于多个IO对象。 异步模型的典型代表是reactor模型。在reactor模型中，我们将所有要处理的IO事件注册到一个中心的IO多路复用器中（一般为epoll/select/poll），同时主线程阻塞在多路复用器上。一旦有IO事件到来或者就绪，多路复用器返回并将对应的IO事件分发到对应的处理器（即回调函数）中，最后处理器调用read/write函数来进行IO操作。
异步模型的特点是性能和可伸缩性比同步模型要好很多，但是其结构复杂，不易于编写和维护。在异步模型中，IO之前的代码（IO任务的提交者）和IO之后的处理代码（回调函数）是割裂开来的。
协程与网络编程
协程的出现出现为克服同步模型和异步模型的缺点，并结合他们的优点提供了可能： 现在假设我们有3个协程A,B,C分别要进行数次IO操作。这3个协程运行在同一个调度器或者说线程的上下文中，并依次使用CPU。调度器在其内部维护了一个多路复用器（epoll/select/poll）。 协程A首先运行，当它执行到一个IO操作，但该IO操作并没有立即就绪时，A将该IO事件注册到调度器中，并主动放弃CPU。这时调度器将B切换到CPU上开始执行，同样，当它碰到一个IO操作的时候将IO事件注册到调度器中，并主动放弃CPU。调度器将C切换到cpu上开始执行。当所有协程都被“阻塞”后，调度器检查注册的IO事件是否发生或就绪。假设此时协程B注册的IO时间已经就绪，调度器将恢复B的执行，B将从上次放弃CPU的地方接着向下运行。A和C同理。 这样，对于每一个协程来说，它是同步的模型；但是对于整个应用程序来说，它是异步的模型。
编程范式
编程范式（Programming Paradigm）是某种编程语言典型的编程风格或者说是编程方式。随着编程方法学和软件工程研究的深入，特别是OO思想的普及，范式（Paradigm）以及编程范式等术语渐渐出现在人们面前。面向对象编程（OOP）常常被誉为是一种革命性的思想，正因为它不同于其他的各种编程范式。编程范式也许是学习任何一门编程语言时要理解的最重要的术语。
托马斯.库恩提出“科学的革命”的范式论之后，Robert Floyd在1979年图灵奖的颁奖演说中使用了编程范式一词。编程范式一般包括三个方面，以OOP为例：
- 学科的逻辑体系——规则范式：如类/对象、继承、动态绑定、方法改写、对象替换等等机制。
- 心理认知因素——心理范式：按照面向对象编程之父Alan Kay的观点，“计算就是模拟”。OO范式极其重视隐喻（metaphor）的价值，通过拟人化，按照自然的方式模拟自然。
- 自然观/世界观——观念范式：强调程序的组织技术，视程序为松散耦合的对象/类的集合，以继承机制将类组织成一个层次结构，把程序运行视为相互服务的对象们之间的对话。
简单的说，编程范式是程序员看待程序应该具有的观点。
为了进一步加深对编程范式的认识，这里介绍几种最常见的编程范式。
需要再次提醒注意的是：编程范式是编程语言的一种分类方式，它并不针对某种编程语言。就编程语言而言，一种编程语言也可以适用多种编程范式。
过程化（命令式）编程
过程化编程，也被称为命令式编程，应该是最原始的、也是我们最熟悉的一种传统的编程方式。从本质上讲，它是“冯.诺伊曼机“运行机制的抽象，它的编程思维方式源于计算机指令的顺序排列。
（也就是说：过程化语言模拟的是计算机机器的系统结构，而并不是基于语言的使用者的个人能力和倾向。这一点我们应该都很清楚，比如：我们最早曾经使用过的单片机的汇编语言。）
过程化编程的步骤是：
首先，我们必须将待解问题的解决方案抽象为一系列概念化的步骤。然后通过编程的方式将这些步骤转化为程序指令集（算法），而这些指令按照一定的顺序排列，用来说明如何执行一个任务或解决一个问题。这就意味着，程序员必须要知道程序要完成什么，并且告诉计算机如何来进行所需的计算工作，包括每个细节操作。简言之，就是将计算机看作一个善始善终服从命令的装置。
所以在过程化编程中，把待解问题规范化、抽象为某种算法是解决问题的关键步骤。其次，才是编写具体算法和完成相应的算法实现问题的正确解决。当然，程序员对待解问题的抽象能力也是非常重要的因素，但这本身已经与编程语言无关了。
程序流程图是过程化语言进行程序编写的有效辅助手段。
尽管现存的计算机编程语言很多，但是人们把所有支持过程化编程范式的编程语言都被归纳为过程化编程语言。例如机器语言、汇编语言、BASIC、COBOL、C 、FORTRAN、语言等等许多第三代编程语言都被归纳为过程化语言。
过程化语言特别适合解决线性（或者说按部就班）的算法问题。它强调“自上而下（自顶向下）”“精益求精”的设计方式。这种方式非常类似我们的工作和生活方式，因为我们的日常活动都是按部就班的顺序进行的。
过程化语言趋向于开发运行较快且对系统资源利用率较高的程序。过程化语言非常的灵活并强大，同时有许多经典应用范例，这使得程序员可以用它来解决多种问题。
过程化语言的不足之处就是它不适合某些种类问题的解决，例如那些非结构化的具有复杂算法的问题。问题出现在，过程化语言必须对一个算法加以详尽的说明，并且其中还要包括执行这些指令或语句的顺序。实际上，给那些非结构化的具有复杂算法的问题给出详尽的算法是极其困难的。
广泛引起争议和讨论的地方是：无条件分支，或goto语句，它是大多数过程式编程语言的组成部分，反对者声称：goto语句可能被无限地滥用；它给程序设计提供了制造混 乱的机会。目前达成的共识是将它保留在大多数语言中，对于它所具有的危险性，应该通过程序设计的规定将其最小化。
事件驱动编程
其实，基于事件驱动的程序设计在图形用户界面（GUI）出现很久前就已经被应用于程序设计中，可是只有当图形用户界面广泛流行时，它才逐渐形演变为一种广泛使用的程序设计模式。
在过程式的程序设计中，代码本身就给出了程序执行的顺序，尽管执行顺序可能会受到程序输入数据的影响。
在事件驱动的程序设计中，程序中的许多部分可能在完全不可预料的时刻被执行。往往这些程序的执行是由用户与正在执行的程序的互动激发所致。
- 事件。就是通知某个特定的事情已经发生（事件发生具有随机性）。
- 事件与轮询。轮询的行为是不断地观察和判断，是一种无休止的行为方式。而事件是静静地等待事情的发生。事实上，在Windows出现之前，采用鼠标输入字符模式的PC应用程序必须进行串行轮询，并以这种方式来查询和响应不同的用户操做。
- 事件处理器。是对事件做出响应时所执行的一段程序代码。事件处理器使得程序能够对于用户的行为做出反映。
事件驱动常常用于用户与程序的交互，通过图形用户接口（鼠标、键盘、触摸板）进行交互式的互动。当然，也可以用于异常的处理和响应用户自定义的事件等等。
事件的异常处理比用户交互更复杂。
事件驱动不仅仅局限在GUI编程应用。但是实现事件驱动我们还需要考虑更多的实际问题，如：事件定义、事件触发、事件转化、事件合并、事件排队、事件分派、事件处理、事 件连带等等。
其实，到目前为止，我们还没有找到有关纯事件驱动编程的语言和类似的开发环境。所有关于事件驱动的资料都是基于GUI事件的。
属于事件驱动的编程语言有：VB、C#、Java（Java Swing的GUI）等。它们所涉及的事件绝大多数都是GUI事件。
面向对象编程
过程化范式要求程序员用按部就班的算法看待每个问题。很显然，并不是每个问题都适合这种过程化的思维方式。这也就导致了其它程序设计范式出现，包括我们现在介绍的面向对象的程序设计范式。
面向对象的程序设计模式已经出现二十多年，经过这些年的发展，它的设计思想和设计模式已经稳定的进入编程语言的主流。来自TIOBE Programming Community2010年11月份编程语言排名的前三名Java、C、C++中，Java和C++都是面向对象的编程语言。
面向对象的程序设计包括了三个基本概念：封装性、继承性、多态性。面向对象的程序语言通过类、方法、对象和消息传递，来支持面向对象的程序设计范式。
1. 对象
世间万事万物都是对象。
面向对象的程序设计的抽象机制是将待解问题抽象为面向对象的程序中的对象。利用封装使每个对象都拥有个体的身份。程序便是成堆的对象，彼此通过消息的传递，请求其它对象 进行工作。
2. 类
每个对象都是其类中的一个实体。
物以类聚——就是说明：类是相似对象的集合。类中的对象可以接受相同的消息。换句话说：类包含和描述了“具有共同特性（数据元素）和共同行为（功能）”的一组对象。
比如：苹果、梨、橘子等等对象都属于水果类。
3. 封装
封装（有时也被称为信息隐藏）就是把数据和行为结合在一个包中，并对对象的使用者隐藏数据的实现过程。信息隐藏是面向对象编程的基本原则，而封装是实现这一原则的一种方 式。
封装使对象呈现出“黑盒子”特性，这是对象再利用和实现可靠性的关键步骤。
4. 接口
每个对象都有接口。接口不是类，而是对符合接口需求的类所作的一套规范。接口说明类应该做什么但不指定如何作的方法。一个类可以有一个或多个接口。
5. 方法
方法决定了某个对象究竟能够接受什么样的消息。面向对象的设计有时也会简单地归纳为“将消息发送给对象”。
6. 继承
继承的思想就是允许在已存在类的基础上构建新的类。一个子类能够继承父类的所有成员，包括属性和方法。
继承的主要作用：通过实现继承完成代码重用；通过接口继承完成代码被重用。继承是一种规范的技巧，而不是一种实现的技巧。
7. 多态
多态提供了“接口与实现分离”。多态不但能改善程序的组织架构及可读性，更利于开发出“可扩充”的程序。
继承是多态的基础。多态是继承的目的。
合理的运用基于类继承的多态、基于接口继承的多态和基于模版的多态，能增强程序的简洁性、灵活性、可维护性、可重用性和可扩展性。
面向对象技术一方面借鉴了哲学、心理学、生物学的思考方式，另一方面，它是建立在其他编程技术之上的，是以前的编程思想的自然产物。
如果说结构化软件设计是将函数式编程技术应用到命令式语言中进行程序设计，面向对象编程不过是将函数式模型应用到命令式程序中的另一途径，此时，模块进步为对象，过程龟缩到class的成员方法中。OOP的很多技术——抽象数据类型、信息隐藏、接口与实现分离、对象生成功能、消息传递机制等等，很多东西就是结构化软件设计所拥有的、或者在其他编程语言中单独出现。但只有在面向对象语言中，他们才共同出现，以一种独特的合作方式互相协作、互相补充。
编程范式 = 语感
知识的学习有几种方式：一种靠记忆，一种靠练习，一种靠培养。就拿英语学习来说吧，学单词，单靠记忆即可；学句型、语法，光记忆是不够的，须要勤加练习方可熟能生巧；而要讲出地道的英语，光记忆和练习是远远不够的。从小学到大学，甚至博士毕业，除了英语类专业的学生外，大多数人英语练了一二十年，水平如何？不客气但很客观地说：一个字，烂。
原因只有一个，那就是国内的英语教学方式严重失策。教学总是围绕单词、词组、句型、语法转，缺乏对语感的重视和培养，导致学生只会‘中式英语’。同样道理，一个惯用C语言编程的人也许很快就能写一些C++程序，但如果他只注重C++的语法而不注重培养OOP 的语感，那么写出的程序一定是‘C 式C++’。与其如此，倒不如直接用C 呢。”
一句话：学习编程范式能增强编程语言的语感。
语感是一个人对语言的敏锐感知力，反映了他在语言方面的整体上的直觉把握能力。语感强者，能听弦外之音，能说双关之语，能读隽永之作，能写晓畅之文。这是一种综合的素质和修养，其重要性是不言而喻的。那么如何培养语感呢？普通的学习和训练固不可少，但如果忽视语言背后的文化背景和思维方式，终究只是缘木求鱼。编程范式正体现了编程的思维方式，因而是培养编程语言的语感的关键。
语感有了，那些设计模式、框架，甚至架构，等看似神秘高深的东西，也会自然而然地来了。
使用yield实现协程操作例子
import time
import queue
def consumer(name):
print("--->starting eating baozi...")
while True:
new_baozi = yield
print("[%s] is eating baozi %s" % (name,new_baozi))
#time.sleep(1)
def producer():
r = con.__next__()
r = con2.__next__()
n = 0
while n < 5:
n +=1
con.send(n)
con2.send(n)
print("\033[32;1m[producer]\033[0m is making baozi %s" %n )
if __name__ == ‘__main__‘:
con = consumer("c1")
con2 = consumer("c2")
p = producer()
符合什么条件就能称之为协程：
- 必须在只有一个单线程里实现并发
- 修改共享数据不需加锁
- 用户程序里自己保存多个控制流的上下文栈
- 一个协程遇到IO操作自动切换到其它协程
基于上面这4点定义，我们刚才用yield实现的程并不能算是合格的线程.
greelet指的是使用一个任务调度器和一些生成器或者协程实现协作式用户空间多线程的一种伪并发机制，即所谓的微线程。
greelet机制的主要思想是：生成器函数或者协程函数中的yield语句挂起函数的执行，直到稍后使用next()或send()操作进行恢复为止。可以使用一个调度器循环在一组生成器函数之间协作多个任务。
网络框架的几种基本的网络I/O模型：
阻塞式单线程：这是最基本的I/O模型，只有在处理完一个请求之后才会处理下一个请求。它的缺点是效能差，如果有请求阻塞住，会让服务无法继续接受请求。但是这种模型编写代码相对简单，在应对访问量不大的情况时是非常适合的。
阻塞式多线程：针对于单线程接受请求量有限的缺点，一个很自然的想法就是给每一个请求开一个线程去处理。这样做的好处是能够接受更多的请求，缺点是在线程产生到一定数量之后，进程之间需要大量进行切换上下文的操作，会占用CPU大量的时间，不过这样处理的话编写代码的难道稍高于单进程的情况。
非阻塞式事件驱动：为了解决多线程的问题，有一种做法是利用一个循环来检查是否有网络IO的事件发生，以便决定如何来进行处理（reactor设计模式）。这样的做的好处是进一步降低了CPU的资源消耗。缺点是这样做会让程序难以编写，因为请求接受后的处理过程由reactor来决定，使得程序的执行流程难以把握。当接受到一个请求后如果涉及到阻塞的操作，这个请求的处理就会停下来去接受另一个请求，程序执行的流程不会像线性程序那样直观。twisted框架就是应用这种IO模型的典型例子。
非阻塞式Coroutine（协程）：这个模式是为了解决事件驱动模型执行流程不直观的问题，它在本质上也是事件驱动的，加入了Coroutine的概念。
与线程/进程的区别
线程是抢占式的调度，多个线程并行执行，抢占共同的系统资源；而微线程是协同式的调度。
其实greenlet不是一种真正的并发机制，而是在同一线程内，在不同函数的执行代码块之间切换，实施“你运行一会、我运行一会”，并且在进行切换时必须指定何时切换以及切换到哪。greenlet的接口是比较简单易用的，但是使用greenlet时的思考方式与其他并发方案存在一定区别：
1. 线程/进程模型在大逻辑上通常从并发角度开始考虑，把能够并行处理的并且值得并行处理的任务分离出来，在不同的线程/进程下运行，然后考虑分离过程可能造成哪些互斥、冲突问题，将互斥的资源加锁保护来保证并发处理的正确性。
2. greenlet则是要求从避免阻塞的角度来进行开发，当出现阻塞时，就显式切换到另一段没有被阻塞的代码段执行，直到原先的阻塞状况消失以后，再人工切换回原来的代码段继续处理。因此，greenlet本质是一种合理安排了的 串行 。
3. greenlet本质是串行，因此在没有进行显式切换时，代码的其他部分是无法被执行到的，如果要避免代码长时间占用运算资源造成程序假死，那么还是要将greenlet与线程/进程机制结合使用（每个线程、进程下都可以建立多个greenlet，但是跨线程/进程时greenlet之间无法切换或通讯）。
使用
一个 “greenlet” 是一个很小的独立微线程。可以把它想像成一个堆栈帧，栈底是初始调用，而栈顶是当前greenlet的暂停位置。你使用greenlet创建一堆这样的堆栈，然后在他们之间跳转执行。跳转不是绝对的：一个greenlet必须选择跳转到选择好的另一个greenlet，这会让前一个挂起，而后一个恢复。两 个greenlet之间的跳转称为 切换(switch) 。
当你创建一个greenlet，它得到一个初始化过的空堆栈；当你第一次切换到它，他会启动指定的函数，然后切换跳出greenlet。当最终栈底 函数结束时，greenlet的堆栈又编程空的了，而greenlet也就死掉了。greenlet也会因为一个未捕捉的异常死掉。
示例：来自官方文档示例
from greenlet import greenlet def test1(): print 12 gr2.switch() print 34 def test2(): print 56 gr1.switch() print 78 gr1 = greenlet(test1) gr2 = greenlet(test2) gr1.switch()
最后一行跳转到 test1() ，它打印12，然后跳转到 test2() ，打印56，然后跳转回 test1() ，打印34，然后 test1() 就结束，gr1死掉。这时执行会回到原来的 gr1.switch() 调用。注意，78是不会被打印的,因为gr1已死，不会再切换。
基于greenlet的框架
eventlet
eventlet 是基于 greenlet 实现的面向网络应用的并发处理框架，提供“线程”池、队列等与其他 Python 线程、进程模型非常相似的 api，并且提供了对 Python 发行版自带库及其他模块的超轻量并发适应性调整方法，比直接使用 greenlet 要方便得多。
其基本原理是调整 Python 的 socket 调用，当发生阻塞时则切换到其他 greenlet 执行，这样来保证资源的有效利用。需要注意的是：
eventlet 提供的函数只能对 Python 代码中的 socket 调用进行处理，而不能对模块的 C 语言部分的 socket 调用进行修改。对后者这类模块，仍然需要把调用模块的代码封装在 Python 标准线程调用中，之后利用 eventlet 提供的适配器实现 eventlet 与标准线程之间的协作。
虽然 eventlet 把 api 封装成了非常类似标准线程库的形式，但两者的实际并发执行流程仍然有明显区别。在没有出现 I/O 阻塞时，除非显式声明，否则当前正在执行的 eventlet 永远不会把 cpu 交给其他的 eventlet，而标准线程则是无论是否出现阻塞，总是由所有线程一起争夺运行资源。所有 eventlet 对 I/O 阻塞无关的大运算量耗时操作基本没有什么帮助。
gevent
gevent是一个基于协程（coroutine）的Python网络函数库，通过使用greenlet提供了一个在libev事件循环顶部的高级别并发API。
主要特性有以下几点：
基于libev的快速事件循环，Linux上面的是epoll机制
基于greenlet的轻量级执行单元
API复用了Python标准库里的内容
支持SSL的协作式sockets
可通过线程池或c-ares实现DNS查询
通过monkey patching功能来使得第三方模块变成协作式
关于Linux的epoll机制：
epoll是Linux内核为处理大批量文件描述符而作了改进的poll，是Linux下多路复用IO接口select/poll的增强版本，它能显著提高程序在大量并发连接中只有少量活跃的情况下的系统CPU利用率。epoll的优点：
支持一个进程打开大数目的socket描述符。select的一个进程所打开的FD由FD_SETSIZE的设置来限定，而epoll没有这个限制，它所支持的FD上限是最大可打开文件的数目，远大于2048。
IO效率不随FD数目增加而线性下降：由于epoll只会对“活跃”的socket进行操作，于是，只有"活跃"的socket才会主动去调用 callback函数，其他idle状态的socket则不会。
使用mmap加速内核与用户空间的消息传递。epoll是通过内核于用户空间mmap同一块内存实现的。
内核微调。
libev机制
提供了指定文件描述符事件发生时调用回调函数的机制。libev是一个事件循环器：向libev注册感兴趣的事件，比如socket可读事件，libev会对所注册的事件的源进行管理，并在事件发生时触发相应的程序。
官方文档中的示例：
>>> import gevent >>> from gevent import socket >>> urls = [‘www.google.com.hk‘,‘www.example.com‘, ‘www.python.org‘ ] >>> jobs = [gevent.spawn(socket.gethostbyname, url) for url in urls] >>> gevent.joinall(jobs, timeout=2) >>> [job.value for job in jobs] [‘74.125.128.199‘, ‘208.77.188.166‘, ‘82.94.164.162‘]
注解：gevent.spawn()方法spawn一些jobs，然后通过gevent.joinall将jobs加入到微线程执行队列中等待其完成，设置超时为2秒。执行后的结果通过检查gevent.Greenlet.value值来收集。gevent.socket.gethostbyname()函数与标准的socket.gethotbyname()有相同的接口，但它不会阻塞整个解释器，因此会使得其他的greenlets跟随着无阻的请求而执行。
Monket patching
Python的运行环境允许我们在运行时修改大部分的对象，包括模块、类甚至函数。虽然这样做会产生“隐式的副作用”，而且出现问题很难调试，但在需要修改Python本身的基础行为时，Monkey patching就派上用场了。Monkey patching能够使得gevent修改标准库里面大部分的阻塞式系统调用，包括socket,ssl,threading和select等模块，而变成协作式运行。
>>> from gevent import monkey ;
>>> monkey . patch_socket ()
>>> import urllib2
通过monkey.patch_socket()方法，urllib2模块可以使用在多微线程环境，达到与gevent共同工作的目的。
事件循环
不像其他网络库，gevent和eventlet类似， 在一个greenlet中隐式开始事件循环。没有必须调用run()或dispatch()的反应器(reactor)，在twisted中是有 reactor的。当gevent的API函数想阻塞时，它获得Hub实例(执行时间循环的greenlet),并切换过去。如果没有集线器实例则会动态 创建。
libev提供的事件循环默认使用系统最快轮询机制，设置LIBEV_FLAGS环境变量可指定轮询机制。LIBEV_FLAGS=1为select， LIBEV_FLAGS = 2为poll， LIBEV_FLAGS = 4为epoll,LIBEV_FLAGS = 8为kqueue。
Libev的API位于gevent.core下。注意libev API的回调在Hub的greenlet运行，因此使用同步greenlet的API。可以使用spawn()和Event.set()等异步API。
python之协程与IO操作