Python3-IO模型

IO模型

1.  IO模型介绍

2. 阻塞IO(blocking IO)

3. 非阻塞IO(non-blocking IO)

4. 多路复用IO(IO multiplexing)

5. 异步IO(Asynchronous I/O)

6. IO模型比较分析

7. selectors模块

 

一 IO模型介绍

本文讨论的背景是Linux环境下的network IO。

在此背景下，有5类IO：

    * blocking IO
    * nonblocking IO
    * IO multiplexing
    * signal driven IO
    * asynchronous IO
    由signal driven IO（信号驱动IO）在实际中并不经常使用，因此主要介绍其他四种IO Model。

 在开始介绍四种IO模型以前，回顾一下同步、异步、阻塞、非阻塞。

同步：

# 所谓同步，就是在发出一个功能调用时，在没有获得结果以前，该调用就不会返回。按照这个定义，其实绝大多数函数都是同步调用。可是通常而言，咱们在说同步、异步的时候，特指那些须要其余部件协做或者须要必定时间完成的任务。 须要搞清楚同步和阻塞IO， 同步无论是IO仍是计算都会停在原地。 # 栗子 #1. multiprocessing.Pool下的apply #发起同步调用后，就在原地等着任务结束，根本不考虑任务是在计算仍是在io阻塞，总之就是一股脑地等任务结束 #2. concurrent.futures.ProcessPoolExecutor().submit(func,).result() #3. concurrent.futures.ThreadPoolExecutor().submit(func,).result()

异步：

# 异步的概念和同步相对。当一个异步功能调用发出后，调用者不能马上获得结果。当该异步功能完成后，经过状态，通知或回调来通知调用者。若是异步功能用状态来通知，那么调用者就须要每隔必定时间检查一次，效率很低（多路复用select）。若是是使用通知的方式，效率则很高，由于异步功能几乎不须要作额外的操做。至于回调函数，其实和通知没多大区别。 # 栗子 #1. multiprocessing.Pool().apply_async() #发起异步调用后，并不会等待任务结束才返回，相反，会当即获取一个临时结果（并非最终的结果，多是封装好的一个对象）。 #2. concurrent.futures.ProcessPoolExecutor(3).submit(func,) #3. concurrent.futures.ThreadPoolExecutor(3).submit(func,)

阻塞：

# 阻塞调用是指调用结果返回以前，当前线程会被挂起（遇到IO，CPU被剥夺走）。函数只有在获得结果以后才会将阻塞的线程激活。跟同步调用对比，同步调用时的线程仍是激活的，只是从逻辑上函数没有返回而已。 # 栗子 #1. 同步调用：apply一个累计1亿次的任务，该调用会一直等待，直到任务返回结果为止，但并未阻塞住（即使是被抢走cpu的执行权限，那也是处于就绪态）; #2. 阻塞调用：当socket工做在阻塞模式的时候，若是没有数据的状况下调用recv函数，则当前线程就会被挂起，直到有数据为止。

非阻塞：

# 非阻塞和阻塞的概念相反，指在不能马上获得结果以前也会马上返回，同事该函数不会阻塞当前线程。

小结：

#1. 同步与异步针对的是函数/任务的调用方式：同步就是当一个进程发起一个函数（任务）调用的时候，一直等到函数（任务）完成，而进程继续处于激活状态。而异步状况下是当一个进程发起一个函数（任务）调用的时候，不会等函数返回，而是继续往下执行当，函数返回的时候经过状态、通知、事件等方式通知进程任务完成。 #2. 阻塞与非阻塞针对的是进程或线程：阻塞是当请求不能知足的时候就将进程挂起，而非阻塞则不会阻塞当前进程

 

对于一个network IO (这里咱们以read举例)，它会涉及到两个系统对象，一个是调用这个IO的process (or thread)，另外一个就是系统内核(kernel)。当一个read操做发生时，该操做会经历两个阶段：

#1 等待数据阶段 （等待数据通过一些列网络延迟以后发送到内核空间） #2 拷贝数据阶段  （将数据从内核拷贝到进程中）

 

二 阻塞IO(blocking IO)

在linux中，默认状况下全部的socket都是blocking，一个典型的读操做流程大概是这样：

 

当用户进程调用了recvfrom这个系统调用，kernel就开始了IO的第一个阶段：准备数据。对于network io来讲，不少时候数据在一开始尚未到达（好比，尚未收到一个完整的UDP包），这个时候kernel就要等待足够的数据到来。

    而在用户进程这边，整个进程会被阻塞。当kernel一直等到数据准备好了，它就会将数据从kernel中拷贝到用户内存，而后kernel返回结果，用户进程才解除block的状态，从新运行起来。
    因此，blocking IO的特色就是在IO执行的两个阶段（等待数据和拷贝数据两个阶段）都被block了。

实际上，除非特别指定，几乎全部的IO接口 ( 包括socket接口 ) 都是阻塞型的。这给网络编程带来了一个很大的问题，如在调用recv(1024)的同时，线程将被阻塞，在此期间，线程将没法执行任何运算或响应任何的网络请求 一个简单的解决方案： #在服务器端使用多线程（或多进程）。多线程（或多进程）的目的是让每一个链接都拥有独立的线程（或进程），这样任何一个链接的阻塞都不会影响其余的链接。 该方案的问题是： #开启多进程或都线程的方式，在遇到要同时响应成百上千路的链接请求，则不管多线程仍是多进程都会严重占据系统资源，下降系统对外界响应效率，并且线程与进程自己也更容易进入假死状态。 改进方案： #不少程序员可能会考虑使用“线程池”或“链接池”。“线程池”旨在减小建立和销毁线程的频率，其维持必定合理数量的线程，并让空闲的线程从新承担新的执行任务。“链接池”维持链接的缓存池，尽可能重用已有的链接、减小建立和关闭链接的频率。这两种技术均可以很好的下降系统开销，都被普遍应用不少大型系统，如websphere、tomcat和各类数据库等。 改进后方案其实也存在着问题： #“线程池”和“链接池”技术也只是在必定程度上缓解了频繁调用IO接口带来的资源占用。并且，所谓“池”始终有其上限，当请求大大超过上限时，“池”构成的系统对外界的响应并不比没有池的时候效果好多少。因此使用“池”必须考虑其面临的响应规模，并根据响应规模调整“池”的大小。

延申

   对应上例中的所面临的可能同时出现的上千甚至上万次的客户端请求，“线程池”或“链接池”或许能够缓解部分压力，可是不能解决全部问题。总之，多线程模型能够方便高效的解决小规模的服务请求，但面对大规模的服务请求，多线程模型也会遇到瓶颈，能够用非阻塞接口来尝试解决这个问题。

 

三 非阻塞IO(non-blocking IO)

    Linux下，能够经过设置socket使其变为non-blocking。当对一个non-blocking socket执行读操做时，流程是这个样子：

    从图中能够看出，当用户进程发出read操做时，若是kernel中的数据尚未准备好，那么它并不会block用户进程，而是马上返回一个error。从用户进程角度讲 ，它发起一个read操做后，并不须要等待，而是立刻就获得了一个结果。用户进程判断结果是一个error时，它就知道数据尚未准备好，因而用户就能够在本次到下次再发起read询问的时间间隔内作其余事情，或者直接再次发送read操做。一旦kernel中的数据准备好了，而且又再次收到了用户进程的system call，那么它立刻就将数据拷贝到了用户内存（这一阶段仍然是阻塞的），而后返回。

    也就是说非阻塞的recvform系统调用调用以后，进程并无被阻塞，内核立刻返回给进程，若是数据还没准备好，此时会返回一个error。进程在返回以后，能够干点别的事情，而后再发起recvform系统调用。重复上面的过程，循环往复的进行recvform系统调用。这个过程一般被称之为轮询。轮询检查内核数据，直到数据准备好，再拷贝数据到进程，进行数据处理。须要注意，拷贝数据整个过程，进程仍然是属于阻塞的状态。

    因此，在非阻塞式IO中，用户进程实际上是须要不断的主动询问kernel数据准备好了没有。

# 服务端 import socket import time server=socket.socket() server.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) server.bind(('127.0.0.1',8083)) server.listen(5) server.setblocking(False) r_list=[] w_list={} while 1: try: conn,addr=server.accept() r_list.append(conn) except BlockingIOError: # 强调强调强调：！！！非阻塞IO的精髓在于彻底没有阻塞！！！ # time.sleep(0.5) # 打开该行注释纯属为了方便查看效果 print('在作其余的事情') print('rlist: ',len(r_list)) print('wlist: ',len(w_list)) # 遍历读列表，依次取出套接字读取内容 del_rlist=[] for conn in r_list: try: data=conn.recv(1024) if not data: conn.close() del_rlist.append(conn) continue w_list[conn]=data.upper() except BlockingIOError: # 没有收成功，则继续检索下一个套接字的接收 continue except ConnectionResetError: # 当前套接字出异常，则关闭，而后加入删除列表，等待被清除 conn.close() del_rlist.append(conn) # 遍历写列表，依次取出套接字发送内容 del_wlist=[] for conn,data in w_list.items(): try: conn.send(data) del_wlist.append(conn) except BlockingIOError: continue # 清理无用的套接字,无需再监听它们的IO操做 for conn in del_rlist: r_list.remove(conn) for conn in del_wlist: w_list.pop(conn) #客户端 import socket import os client=socket.socket() client.connect(('127.0.0.1',8083)) while 1: res=('%s hello' %os.getpid()).encode('utf-8') client.send(res) data=client.recv(1024) print(data.decode('utf-8')) 非阻塞IO示例

非阻塞IO例子

    可是非阻塞IO模型毫不被推荐。

    咱们不可否则其优势：可以在等待任务完成的时间里干其余活了（包括提交其余任务，也就是 “后台” 能够有多个任务在“”同时“”执行）。

    可是也难掩其缺点：

#1. 循环调用recv()将大幅度推高CPU占用率；这也是咱们在代码中留一句time.sleep(2)的缘由,不然在低配主机下极容易出现卡机状况 #2. 任务完成的响应延迟增大了，由于每过一段时间才去轮询一次read操做，而任务可能在两次轮询之间的任意时间完成。这会致使总体数据吞吐量的下降。

 

 

四 多路复用IO(IO multiplexing)

    IO multiplexing这个词可能有点陌生，可是若是我说select/epoll，大概就都能明白了。有些地方也称这种IO方式为事件驱动IO(event driven IO)。咱们都知道，select/epoll的好处就在于单个process就能够同时处理多个网络链接的IO。它的基本原理就是select/epoll这个function会不断的轮询所负责的全部socket，当某个socket有数据到达了，就通知用户进程。它的流程如图：

当用户进程调用了select，那么整个进程会被block，而同时，kernel会“监视”全部select负责的socket，当任何一个socket中的数据准备好了，select就会返回。这个时候用户进程再调用read操做，将数据从kernel拷贝到用户进程。

    这个图和blocking IO的图其实并无太大的不一样，事实上还更差一些。由于这里须要使用两个系统调用(select和recvfrom)，而blocking IO只调用了一个系统调用(recvfrom)。可是，用select的优点在于它能够同时处理多个connection。

    强调：

    1. 若是处理的链接数不是很高的话，使用select/epoll的web server不必定比使用multi-threading + blocking IO的web server性能更好，可能延迟还更大。select/epoll的优点并非对于单个链接能处理得更快，而是在于能处理更多的链接。

    2. 在多路复用模型中，对于每个socket，通常都设置成为non-blocking，可是，如上图所示，整个用户的process实际上是一直被block的。只不过process是被select这个函数block，而不是被socket IO给block。

    结论: select的优点在于能够处理多个链接，不适用于单个链接  

#服务端 from socket import * import select server = socket(AF_INET, SOCK_STREAM) server.bind(('127.0.0.1',8093)) server.listen(5) server.setblocking(False) print('starting...') rlist=[server,] wlist=[] wdata={} while True: rl,wl,xl=select.select(rlist,wlist,[],0.5) print(wl) for sock in rl: if sock == server: conn,addr=sock.accept() rlist.append(conn) else: try: data=sock.recv(1024) if not data: sock.close() rlist.remove(sock) continue wlist.append(sock) wdata[sock]=data.upper() except Exception: sock.close() rlist.remove(sock) for sock in wl: sock.send(wdata[sock]) wlist.remove(sock) wdata.pop(sock) #客户端 from socket import * client=socket(AF_INET,SOCK_STREAM) client.connect(('127.0.0.1',8093)) while True: msg=input('>>: ').strip() if not msg:continue client.send(msg.encode('utf-8')) data=client.recv(1024) print(data.decode('utf-8')) client.close() select网络IO模型

select网络IO模型

 

 select监听fd变化的过程分析：

#用户进程建立socket对象，拷贝监听的fd到内核空间，每个fd会对应一张系统文件表，内核空间的fd响应到数据后，就会发送信号给用户进程数据已到； #用户进程再发送系统调用，好比（accept）将内核空间的数据copy到用户空间，同时做为接受数据端内核空间的数据清除，这样从新监听时fd再有新的数据又能够响应到了（发送端由于基于TCP协议因此须要收到应答后才会清除）。

该模型的优势：

#相比其余模型，使用select() 的事件驱动模型只用单线程（进程）执行，占用资源少，不消耗太多 CPU，同时可以为多客户端提供服务。若是试图创建一个简单的事件驱动的服务器程序，这个模型有必定的参考价值。

该模型的缺点：

#首先select()接口并非实现“事件驱动”的最好选择。由于当须要探测的句柄值较大时，select()接口自己须要消耗大量时间去轮询各个句柄。不少操做系统提供了更为高效的接口，如linux提供了epoll，BSD提供了kqueue，Solaris提供了/dev/poll，…。若是须要实现更高效的服务器程序，相似epoll这样的接口更被推荐。遗憾的是不一样的操做系统特供的epoll接口有很大差别，因此使用相似于epoll的接口实现具备较好跨平台能力的服务器会比较困难。 #其次，该模型将事件探测和事件响应夹杂在一块儿，一旦事件响应的执行体庞大，则对整个模型是灾难性的。

 

五 异步IO(Asynchronous I/O)

Linux下的asynchronous IO其实用得很少，从内核2.6版本才开始引入。先看一下它的流程：

    用户进程发起read操做以后，马上就能够开始去作其它的事。而另外一方面，从kernel的角度，当它受到一个asynchronous read以后，首先它会马上返回，因此不会对用户进程产生任何block。而后，kernel会等待数据准备完成，而后将数据拷贝到用户内存，当这一切都完成以后，kernel会给用户进程发送一个signal，告诉它read操做完成了。

PS：异步IO对服务端的开销比较大，由于不少数据都是服务端主动去响应呢：客户端发送了一个请求，服务端返回一个响应码，而后客户端就能够去干其余事情了；数据到达内核空间后，内核还会把数据放到用户的内存空间，而后通知客户端数据已经送到了。

 

 

IO模型比较分析

到目前为止，已经将四个IO Model都介绍完了。如今回过头来回答最初的那几个问题：blocking和non-blocking的区别在哪，synchronous IO和asynchronous IO的区别在哪。

先回答最简单的这个：blocking vs non-blocking。

前面的介绍中其实已经很明确的说明了这二者的区别。调用blocking IO会一直block住对应的进程直到操做完成，而non-blocking IO在kernel等待数据阶段的状况下会马上返回。

再说明synchronous IO和asynchronous IO的区别以前，须要先给出二者的定义。

　　　　同步I/O操做会致使请求进程被阻塞，直到I/O操做完成为止；

　　　　异步I/O操做不会致使请求进程被阻止

二者的区别就在于synchronous IO作”IO operation”的时候会将process阻塞。按照这个定义，四个IO模型能够分为两大类，以前所述的blocking IO，non-blocking IO，IO multiplexing都属于synchronous IO这一类，而 asynchronous I/O后一类 。 有人可能会说，non-blocking IO并无被block啊。这里有个很是“狡猾”的地方，在non-blocking数据准备阶段的时候，kernel的数据没准备好，不会block进程。可是当kernel的数据准备好以后，会进入数据拷贝阶段（从kernel空间拷贝到用户空间），这段时间内，进程是被block的。 而asynchronous IO则不同，当进程发起IO 操做以后，就直接返回不再理睬了，直到kernel发送一个信号，告诉进程说IO完成。在这整个过程当中，进程彻底没有被block。

 

 各个IO Model的比较如图所示：

 

通过上面的介绍，会发现non-blocking IO和asynchronous IO的区别仍是很明显的。在non-blocking IO中，虽然进程大部分时间都不会被block，可是它仍然要求进程去主动的check，而且当数据准备完成之后，也须要进程主动的再次调用recvfrom来将数据拷贝到用户内存。而asynchronous IO则彻底不一样。它就像是用户进程将整个IO操做交给了他人（kernel）完成，而后他人作完后发信号通知。在此期间，用户进程不须要去检查IO操做的状态，也不须要主动的去拷贝数据。

 

 

selectors模块

IO复用： 为了解释这个名字，首先来理解一下复用这个概念，复用也就是公用的意思，这样理解可能会有点抽象，因此，仍是先来理解下复用在通讯领域的使用，在通讯领域中为了充分利用网络接连的物理介质，每每在同一条网络链路上采用时分复用和频分复用的技术使其在同一链路上传输多路信号，到这里咱们就基本上理解了复用的含义，即公用某个介质来尽量作多的同一类（性质）的事,那IO复用的'介质'是什么呢？为此咱们首先来看看服务器编程的模型，客户端发来请求的时候服务端会产生一个进程来对其进行服务，每当来一个客户请求就产生一个进程来服务，然而进程不可能无限制的产生，为了解决大量客户端访问的问题，引入了IO复用技术，即：一个进程能够同时对多个客户端请求进行服务。也就是说IO复用的'介质'是进程（准确的说复用的是select和poll， 由于进程也是调用select和poll来实现的），复用一个进程（select和poll）来对多个IO进行服务，虽然客户端发来的IO是并发的可是IO所需的读写数据多状况下是没有准备好的，由于就能够利用一个函数（select和epoll）来监听IO所需的这些数据状态，一旦IO有数据能够进行读写了，进程就对这样的IO进行服务。 理解完IO复用后，咱们在来看下实现IO复用中的三个API(select、poll和epoll)的区别和联系 select, poll, epoll都是IO多路复用的机制， I/O多路复用就是经过一种机制，能够监视多个描述符，一旦某个描述符（通常是读就绪或者写就绪），可以通知应用程序进行相应的读写操做。但select，poll，epoll本质上都是同步IO,由于他们都须要在读写事件（数据准备阶段）就绪后本身负责进行读写（数据拷贝阶段），整个读写过程是阻塞的，而异步I/O则无需本身负责进行读写，异步I/O的实现会负责把数据从内核拷贝到用户空间。 select: select最先于1983年出如今4.2BSD中，他经过一个select()系统调用来监视多个文件描述符的数组，当select()返回后，该数组中就绪的文件描述符便会被内核修改标志位，使得进程能够得到这些文件描述符从而进行后续的读写操做。 select目前几乎在全部的平台上支持，其良好跨平台支持是他的一个优势，事实上从如今看来，这也是他所剩很少的优势之一。 select的一个缺点在于单个进程可以监视的文件描述符的数量存在最大限制，在Linux上通常为1024，不过能够经过修改宏定义或者从新编译内核的方式突破这一限制。 另外，select()所维护的存储大量文件描述符的数据结构，随着文件描述符数量的增大，其复制的开销也线性增加。同时，因为网络响应时间的延迟使得大量TCP链接处于很是活跃状态，但调用select()会对全部socket进行一次线性扫描，因此这也形成了必定的开销。 poll： poll在1986年诞生于System V Release 3，他和socket在本质上没有多大差异，可是poll没有最大文件描述符数量的限制。 poll和select一样存在的一个缺点是，包含大量文件描述符的数组被总体复制于用户态和内核的地址空间之间，而不论这些文件描述符是否就绪，他的开销随着文件描述符数量的增长而线性增大。 另外，select（）和epoll（）将就绪的文件描述符告诉进程后，若是进程没有对其进行IO操做，那么下次调用select（）和poll（）的时候将再次报告这个文件描述符，因此他们通常不会丢失就绪信息，这种方式成为水平触发（Level Triggered） epoll： 直到linux2.6才出现了由内核直接支持的实现方法，那就是epoll，它几乎具有了以前全部所说的一切优势，被公认为Linux2.6下性能最好的多路I/O就绪通知方法。 epoll能够同时支持水平触发和边缘触发（Edge Triggered，只告诉进程哪些描述符刚刚变成就绪状态，它只说一遍，若是咱们没有采起行动，那么它将不会再次告知，这种方法称为边缘触发），理论上边缘触发的性能要高一些，可是代码实现至关复杂。 epoll一样只告知那些就绪的文件描述符，并且当咱们调用epoll_wait()得到就绪文件描述符的时候，返回的不是实际的描述符，而是一个表明就绪描述数量的值，你只须要去epoll指定的一个数组中依次取得相应数量的文件描述符便可，这里也使用了内存映射（mmap）技术，这样便完全省掉了这些文件描述符在系统调用时复制的开销。 另外一个本质的改进在于epoll采用基于时间的就绪通知方法。在select、poll中，进程只有在调用相关的方法后，内核才对全部监视的文件进行扫描，而epoll是先经过epoll_ctl（）来注册一个文件描述符，一旦基于某个文件描述符就绪时，内核会采用相似callback的回调机制，迅速激活这个文件描述符，当进程调用epoll_wait（）时便获得通知。

select、poll、epoll

这三种IO多路复用模型在不一样的平台有着不一样的支持，而epoll在windows下就不支持，好在咱们有selectors模块，帮咱们默认选择当前平台下最合适的

#服务端 from socket import * import selectors sel=selectors.DefaultSelector() def accept(server_fileobj,mask): conn,addr=server_fileobj.accept() sel.register(conn,selectors.EVENT_READ,read) def read(conn,mask): try: data=conn.recv(1024) if not data: print('closing',conn) sel.unregister(conn) conn.close() return conn.send(data.upper()+b'_SB') except Exception: print('closing', conn) sel.unregister(conn) conn.close() server_fileobj=socket(AF_INET,SOCK_STREAM) server_fileobj.setsockopt(SOL_SOCKET,SO_REUSEADDR,1) server_fileobj.bind(('127.0.0.1',8088)) server_fileobj.listen(5) server_fileobj.setblocking(False) #设置socket的接口为非阻塞 sel.register(server_fileobj,selectors.EVENT_READ,accept) #至关于网select的读列表里append了一个文件句柄server_fileobj,而且绑定了一个回调函数accept while True: events=sel.select() #检测全部的fileobj，是否有完成wait data的 for sel_obj,mask in events: callback=sel_obj.data #callback=accpet callback(sel_obj.fileobj,mask) #accpet(server_fileobj,1) #客户端 from socket import * c=socket(AF_INET,SOCK_STREAM) c.connect(('127.0.0.1',8088)) while True: msg=input('>>: ') if not msg:continue c.send(msg.encode('utf-8')) data=c.recv(1024) print(data.decode('utf-8')) 基于selectors模块实现聊天

selectors实现聊天

 

参考文章：http://www.cnblogs.com/linhaifeng/articles/7454717.html