本文介绍了Python中的I/O模型，包括阻塞IO、非阻塞IO、IO多路复用、异步IO等，详细解析了各模型的工作原理及优缺点。重点探讨了阻塞与非阻塞、同步与异步的概念，以及它们在IO模型中的应用。
I/O模型
I/O模型介绍
1.知识回顾
在了解IO模型之前，先回顾4个概念：什么是阻塞（blocking），非阻塞（non-blocking），同步（synchronous），异步（asynchronous）。
-
阻塞：指调用结果返回之前，当前线程会被挂起（如遇到io操作）。函数只有在得到结果之后才会将阻塞的线程激活。
-
非阻塞：指在不能立刻得到结果之前也会立刻返回，同时该函数不会阻塞当前线程。
-
同步：指在发出一个功能调用时，在没有得到结果之前，该调用就不会返回，但该线程依然是激活状态。
举个栗子：
1. multiprocessing.Pool下的apply #发起同步调用后，就在原地等着任务结束，根本不考虑任务是在计算还是在io阻塞，总之就是一股脑地等任务结束
2. concurrent.futures.ProcessPoolExecutor().submit(func,).result()
3. concurrent.futures.ThreadPoolExecutor().submit(func,).result()
- 异步：当一个异步功能调用发出后，调用者不能立刻得到结果。当该异步功能完成后，通过状态、通知或回调来通知调用者。如果异步功能用状态来通知，那么调用者就需要每隔一定时间检查一次，效率就很低；如果是使用通知的方式，效率则很高，因为异步功能几乎不需要做额外的操作。
#举个栗子：
1. multiprocessing.Pool().apply_async() #发起异步调用后，并不会等待任务结束才返回，相反，会立即获取一个临时结果（并不是最终的结果，可能是封装好的一个对象）。
2. concurrent.futures.ProcessPoolExecutor(3).submit(func,)
3. concurrent.futures.ThreadPoolExecutor(3).submit(func,)
有人也许会把阻塞调用和同步调用等同起来，实际上他是不同的。对于同步调用来说，很多时候当前线程还是激活的，只是从逻辑上当前函数没有返回而已。
举个栗子：
1. 同步调用：apply一个累计1亿次的任务，该调用会一直等待，直到任务返回结果为止，但并未阻塞住（即便是被抢走cpu的执行权限，那也是处于就绪态）;
2. 阻塞调用：当socket工作在阻塞模式的时候，如果没有数据的情况下调用recv函数，则当前线程就会被挂起，直到有数据为止。
小结：
-
同步与异步针对的是函数/任务的调用方式：同步就是当一个进程发起一个函数（任务）调用的时候，一直等到函数（任务）完成，而进程继续处于激活状态。而异步情况下是当一个进程发起一个函数（任务）调用的时候，不会等函数返回，而是继续往下执行当，函数返回的时候通过状态、通知、事件等方式通知进程任务完成。
-
阻塞与非阻塞针对的是进程或线程：阻塞是当请求不能满足的时候就将进程挂起，而非阻塞则不会阻塞当前进程。
2.IO模型
在网络环境中，我们接收的信息都需要耐性的等待对方的发送，也就是IO可以分为两步：
- 等待数据发送(Waiting for the data to be ready)
- 拷贝数据(Copying the data from the kernel to the process)
- IO模型可以分为5种：阻塞IO(blocking IO)、非阻塞IO(nonblocking IO)、IO多路复用(IO multiplexing)、信号驱动IO(signal driven IO)、异步IO(asynchronous IO)。前面四种模型为同步的，只有最后一种模型为异步。
因为信号驱动IO(signal driven IO)在实际中不经常使用，在此不过多阐述。
| 操作模式 | 描述 |
|---|---|
| 输入操作：read、readv、recv、recvfrom、recvmsg共5个函数 | 如果会阻塞状态，则会经历wait data和copy data两个阶段，如果设置为非阻塞则在wait 不到data时抛出异常 |
| 输出操作：write、writev、send、sendto、sendmsg共5个函数 | 在发送缓冲区满了会阻塞在原地，如果设置为非阻塞，则会抛出异常 |
| 接收外来链接：accept | 与输入操作类似 |
| 发起外出链接：connect | 与输出操作类似 |
3. 阻塞IO(blocking IO)
当用户进程调用了recvfrom这个系统调用，kernel就开始了IO的第一个阶段：准备数据（对于网络IO来说，很多时候数据在一开始还没有到达。比如，还没有收到一个完整的UDP包。）这个时候kernel就要等待足够的数据到来，磁盘I/O的情况就是等待磁盘数据从磁盘上读取到内核态内存中。这个过程需要等待，也就是说数据被拷贝到操作系统内核的缓冲区中是需要一个过程的。而在用户进程这边，整个进程会被阻塞（当然，是进程自己选择的阻塞）。当kernel一直等到数据准备好了，它就会将数据从kernel中拷贝到用户内存(出于系统安全,用户态的程序没有权限直接读取内核态内存,因此内核负责把内核态内存中的数据拷贝一份到用户态内存中)，然后kernel返回结果，用户进程才解除block的状态，重新运行起来。
所以，blocking IO的特点就是在IO执行的两个阶段都被block了，整个过程发生了一次系统调用。
| 阻塞IO | 描述 |
|---|---|
| 典型应用 | 阻塞Socket |
| 优点 | 进程阻塞挂起不消耗CPU资源；能够及时响应每个操作；实现难度低；开发较为容易 ；适合并发量小的网络应用开发 |
| 缺点 | 不适合并发量大的开发；请求分配一个处理进线程才能及时响应，导致系统开销大 |
4.阻塞型接口
阻塞型接口是指系统调用（一般是IO接口）不返回调用结果并让当前线程一直阻塞，只有当该系统调用获得结果或者超时出错时才返回。大多数IO接口都是阻塞型的，如调用accept()的同时，线程将被阻塞，在这个时间内线程无法响应其他连接或其他网络请求。
- 一个简单的解决方案：
在服务器端使用多线程（或多进程）。多线程（或多进程）的目的是让每个连接都拥有独立的线程（或进程），这样任何一个连接的阻塞都不会影响其他的连接。 - 该方案带来的问题：
开启多线程或者进程的目的是需要服务大量的请求，但是无论是哪种做法，这都将会大大严重的占据系统资源，降低系统对外界的响应效率。 - 新的方案：
竟然线程，所能服务的数量比较少，而且资源占用大，那么就使用“线程池”或“连接池”。“线程池”旨在减少创建和销毁线程的频率，其维持一定合理数量的线程，并让空闲的线程重新承担新的执行任务。“连接池”维持连接的缓存池，尽量重用已有的连接、 减少创建和关闭连接的频率。这两种技术都可以很好的降低系统开销，都被广泛应用很多大型系统，如websphere、tomcat和各种数据库等。 - 改进后方案其实也存在着问题：
“线程池”和“连接池”技术也只是在一定程度上缓解了频繁调用IO接口带来的资源占用。而且，所谓“池”始终有其上限，当请求大大超过上限时，“池”构成的系统对外界的响应并不比没有池的时候效果好多少。所以使用“池”必须考虑其面临的响应规模，并根据响应规模调整“池”的大小。
小结：
对应上例中的所面临的可能同时出现的上千甚至上万次的客户端请求，“线程池”或“连接池”或许可以缓解部分压力，但是不能解决所有问题。总之，多线程模型可以方便高效的解决小规模的服务请求，但面对大规模的服务请求，多线程模型也会遇到瓶颈，可以用非阻塞接口来尝试解决这个问题。
5.非阻塞IO(non-blocking IO)
当用户进程发出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示例
该模型虽然解决了在线程等待时间内完成其他任务，但是缺点也是很明显。
- 循环调用recv()将大幅度推高CPU占用率；在低配主机下极容易出现卡机情况
- 任务完成的响应延迟增大了，因为每过一段时间才去轮询一次read操作，而任务可能在两次轮询之间的任意时间完成。这会导致整体数据响应不及时。
因为这些缺点，我们并不建议使用非阻塞IO模型。
6.IO多路复用(IO multiplexing)
在介绍非阻塞IO模型种，我们了解到recv()更多的是起到检测“操作是否完成”的作用。但是在实际操作系统种提供了更为高效的检测“操作是否完成“作用的接口，例如select()多路复用模式，可以一次检测多个连接是否活跃。
IO多路复用(IO multiplexing)有些地方也称该模式为事件驱动IO(event driven IO)。它的基本原理就是select/epoll这个function会不断的轮询所负责的所有socket，当某个socket有数据到达了，就通知用户进程。
当用户进程调用了select，那么整个进程会被block，而同时，kernel会“监视”所有select负责的socket，当任何一个socket中的数据准备好了，select就会返回。这个时候用户进程再调用read操作，将数据从kernel拷贝到用户进程。
这个图和blocking IO的图其实并没有太大的不同，事实上还更差一些。因为这里需要使用两个系统调用(select和recvfrom)，而blocking IO只调用了一个系统调用(recvfrom)。但是，用select的优势在于它可以同时处理多个connection。
注意点：
-
如果处理的连接数不是很高的话，使用select/epoll的web server不一定比使用multi-threading + blocking IO的web server性能更好，可能延迟还更大。select/epoll的优势并不是对于单个连接能处理得更快，而是在于能处理更多的连接。
-
在多路复用模型中，对于每一个socket，一般都设置成为non-blocking，但是，如上图所示，整个用户的process其实是一直被block的。只不过process是被select这个函数block，而不是被socket IO给block。
结论: select的优势在于可以处理多个连接，不适用于单个连接
#***********************server.py###################
import socket
import select
sk=socket.socket()
sk.bind(("127.0.0.1",8801))
sk.listen(5)
rlist=[sk,]
wlist = []
xlist = []
while True:
r,w,e=select.select(rlist, wlist, xlist, 5)
for obj in r:#[sk,]
if obj==sk:
conn,add=obj.accept()
print(conn)
rlist.append(conn)
else:
try:
data_byte=obj.recv(1024)
print(str(data_byte,'utf8'))
inp=input('回答%s号客户>>>'%rlist.index(obj))
obj.sendall(bytes(inp,'utf8'))
except Exception as e:
obj.close()
rlist.remove(obj)
print('客户连接数：',len(rlist)-1)
#***********************client.py###################
import socket
sk = socket.socket()
sk.connect(('127.0.0.1', 8801))
while True:
inp = input(">>>>")
sk.sendall(bytes(inp, "utf8"))
data = sk.recv(1024)
print(str(data, 'utf8'))
| IO多路复用 | 描述 |
|---|---|
| 优点 | 使用select() 的事件驱动模型只用单线程（进程）执行，占用资源少，不消耗太多 CPU，同时能够为多客户端提供服务。如果试图建立一个简单的事件驱动的服务器程序，这个模型有一定的参考价值。 |
| 缺点1 | 首先select()接口并不是实现“事件驱动”的最好选择。因为当需要探测的句柄值较大时，select()接口本身需要消耗大量时间去轮询各个句柄。多操作系统提供了更为高效的接口，如linux提供了epoll，BSD提供了kqueue，Solaris提供了/dev/poll，…。如果需要实现更高效的服务器程序，类似epoll这样的接口更被推荐。遗憾的是不同的操作系统特供的epoll接口有很大差异，所以使用类似于epoll的接口实现具有较好跨平台能力的服务器会比较困难。 |
| 缺点2 | 该模型将事件探测和事件响应夹杂在一起，一旦事件响应的执行体庞大，则对整个模型是灾难性的。 |
7.异步IO(asynchronous IO)
当应用程序调用aio_read时，内核一方面去取数据报内容返回，另一方面将程序控制权还给应用进程，应用进程继续处理其他事情，是一种非阻塞的状态。
当内核中有数据报就绪时，由内核将数据报拷贝到应用程序中，返回aio_read中定义好的函数处理程序。
异步IO最大的优点就是全程无阻塞。
异步IO的工作机制是：告知内核启动某个操作、并让内核在整个操作完成后通知应用程序。
8.五个IO模型的比较
- 阻塞IO与非阻塞IO的比较：
调用blocking IO会一直block住对应的进程直到操作完成，而non-blocking IO在kernel还准备数据的情况下会立刻返回。 - 同步IO与异步IO 的比较：
non-blocking IO并没有被block啊。这里有个非常“狡猾”的地方，定义中所指的”IO operation”是指真实的IO操作，就是例子中的recvfrom这个system call。non-blocking IO在执行recvfrom这个system call的时候，如果kernel的数据没有准备好，这时候不会block进程。但是，当kernel中数据准备好的时候，recvfrom会将数据从kernel拷贝到用户内存中，这个时候进程是被block了，在这段时间内，进程是被block的。而asynchronous IO则不一样，当进程发起IO 操作之后，就直接返回再也不理睬了，直到kernel发送一个信号，告诉进程说IO完成。在这整个过程中，进程完全没有被block。
我们会发现non-blocking IO和asynchronous IO的区别还是很明显的。在non-blocking IO中，虽然进程大部分时间都不会被block，但是它仍然要求进程去主动的check，并且当数据准备完成以后，也需要进程主动的再次调用recvfrom来将数据拷贝到用户内存。而asynchronous IO则完全不同。它就像是用户进程将整个IO操作交给了他人（kernel）完成，然后他人做完后发信号通知。在此期间，用户进程不需要去检查IO操作的状态，也不需要主动的去拷贝数据。
扫一扫
4万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
