python并发编程：IO模型

IO发生时涉及的对象和步骤：
对于一个network IO (这里我们以read举例)，它会涉及到两个系统对象，
　　1、一个是调用这个IO的process (or thread)，
　　2、另一个就是系统内核(kernel)。
当一个read操作发生时，它会经历两个阶段：
　　1、等待数据准备 (Waiting for the data to be ready)
　　2、将数据从内核拷贝到进程中 (Copying the data from the kernel to the process)

记住这两点很重要，因为这些IO Model的区别就是在两个阶段上各有不同的情况。

常见的几种IO 模型：

• blocking IO          （阻塞IO）
  

• nonblocking IO    （非阻塞IO）
  

• IO multiplexing    （IO多路复用）
  

• signal driven IO   （信号驱动式IO）
  

• asynchronous IO  （异步IO）
  

1、 blocking IO（阻塞IO模型）

在linux中，默认情况下所有的socket都是blocking，一个典型的读操作流程大概是这样：

当用户进程调用了recvfrom这个系统调用，kernel就开始了IO的第一个阶段：准备数据。对于network io来说，很多时候数据在一开始还没有到达（比如，还没有收到一个完整的UDP包），这个时候kernel就要等待足够的数据到来。而在用户进程这边，整个进程会被阻塞。当kernel一直等到数据准备好了，它就会将数据从kernel中拷贝到用户内存，然后kernel返回结果，用户进程才解除block的状态，重新运行起来。
所以，blocking IO的特点就是在IO执行的两个阶段都被block了。

# server.py
import socket

sk=socket.socket()

sk.bind(("127.0.0.1",8080))

sk.listen(5)

while 1:
    conn,addr=sk.accept()

    while 1:
        conn.send("hello client".encode("utf8"))
        data=conn.recv(1024)
        print(data.decode("utf8"))

#client.py
import socket

sk=socket.socket()

sk.connect(("127.0.0.1",8080))

while 1:
    data=sk.recv(1024)
    print(data.decode("utf8"))
    sk.send(b"hello server")

2、non-blocking IO(非阻塞IO)

linux下，可以通过设置socket使其变为non-blocking。当对一个non-blocking socket执行读操作时，流程是这个样子：

　　从图中可以看出，当用户进程发出read操作时，如果kernel中的数据还没有准备好，那么它并不会block用户进程，而是立刻返回一个error。从用户进程角度讲 ，它发起一个read操作后，并不需要等待，而是马上就得到了一个结果。用户进程判断结果是一个error时，它就知道数据还没有准备好，于是它可以再次发送read操作。一旦kernel中的数据准备好了，并且又再次收到了用户进程的system call，那么它马上就将数据拷贝到了用户内存，然后返回。
所以，用户进程其实是需要不断的主动询问kernel数据好了没有。

注意：
在网络IO时候，非阻塞IO也会进行recvform系统调用，检查数据是否准备好，与阻塞IO不一样，”非阻塞将大的整片时间的阻塞分成N多的小的阻塞, 所以进程不断地有机会 ‘被’ CPU光顾”。即每次recvform系统调用之间，cpu的权限还在进程手中，这段时间是可以做其他事情的，
也就是说非阻塞的recvform系统调用调用之后，进程并没有被阻塞，内核马上返回给进程，如果数据还没准备好，此时会返回一个error。进程在返回之后，可以干点别的事情，然后再发起recvform系统调用。重复上面的过程，循环往复的进行recvform系统调用。这个过程通常被称之为轮询。轮询检查内核数据，直到数据准备好，再拷贝数据到进程，进行数据处理。需要注意，拷贝数据整个过程，进程仍然是属于阻塞的状态。

# server.py
import time
import socket
sk = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
sk.bind(('127.0.0.1',6667))
sk.listen(5)
sk.setblocking(False)  #设置成非阻塞状态
while True:
    try:  
        print ('waiting client connection .......')
        connection,address = sk.accept()   # 进程主动轮询
        print("+++",address)
        client_messge = connection.recv(1024)
        print(str(client_messge,'utf8'))
        connection.close()
    except Exception as e:  #捕捉错误
        print (e)
        time.sleep(4)  #每4秒打印一个捕捉到的错误

#client.py
import time
import socket
sk = socket.socket(socket.AF_INET,socket.SOCK_STREAM)

while True:
    sk.connect(('127.0.0.1',6667))
    print("hello")
    sk.sendall(bytes("hello","utf8"))
    time.sleep(2)
    break

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

缺点：任务完成的响应延迟增大了，因为每过一段时间才去轮询一次read操作，而任务可能在两次轮询之间的任意时间完成。这会导致整体数据吞吐量的降低。1、发送了太多系统调用数据,2、数据处理不及时

3 IO multiplexing（IO多路复用）

IO多路复用的三种方式：

1、select—>效率最低，但有最大描述符限制，在linux为1024。

2、poll ---->和select一样，但没有最大描述符限制。

3、epoll —>效率最高，没有最大描述符限制，支持水平触发与边缘触发。

$IO多路复用的优势：同时可以监听多个连接，用的是单线程，利用空闲时间实现并发。$
注意：

Linux系统： select、poll、epoll

Windows系统：select

Mac系统：select、poll

它的基本原理就是select/epoll这个function会不断的轮询所负责的所有socket，当某个socket有数据到达了，就通知用户进程。它的流程如图：

当用户进程调用了select，那么整个进程会被block，而同时，kernel会“监视”所有select负责的socket，当任何一个socket中的数据准备好了，select就会返回。这个时候用户进程再调用read操作，将数据从kernel拷贝到用户进程。
这个图和blocking IO的图其实并没有太大的不同，事实上，还更差一些。因为这里需要使用两个system call (select 和 recvfrom)，而blocking IO只调用了一个system call (recvfrom)。但是，用select的优势在于它可以同时处理多个connection。(所以，如果处理的连接数不是很高的话，使用select/epoll的web server不一定比使用multi-threading + blocking IO的web server性能更好，可能延迟还更大。select/epoll的优势并不是对于单个连接能处理得更快，而是在于能处理更多的连接。）
　　select函数返回结果中如果有文件可读了，那么进程就可以通过调用accept()或recv()来让kernel将位于内核中准备到的数据copy到用户区。
结论: select的优势在于可以处理多个连接，不适用于单个连接

# server.py
#server.py

import socket
import select
sk=socket.socket()
sk.bind(("127.0.0.1",9904))
sk.listen(5)

while True:
    # sk.accept() #文件描述符
    # 没有人链接  会一直卡在这里
    r,w,e=select.select([sk,],[],[],5)  #输入列表，输出列表，错误列表,5: 是监听5秒，每隔5秒监听一次
    for i in r:   #[sk,]
        conn,add=i.accept()
        print(conn)
        print("hello")
    print('>>>>>>')

#client.py
import socket

sk=socket.socket()

sk.connect(("127.0.0.1",9904))

while 1:
    inp=input(">>").strip()
    sk.send(inp.encode("utf8"))
    data=sk.recv(1024)
    print(data.decode("utf8"))

IO多路复用中的两种触发方式：
　　水平触发:如果文件描述符已经就绪可以非阻塞的执行IO操作了,此时会触发通知.允许在任意时刻重复检测IO的状态, 没有必要每次描述符就绪后尽可能多的执行IO.select,poll就属于水平触发。
　　边缘触发:如果文件描述符自上次状态改变后有新的IO活动到来,此时会触发通知.在收到一个IO事件通知后要尽可能 多的执行IO操作,因为如果在一次通知中没有执行完IO那么就需要等到下一次新的IO活动到来才能获取到就绪的描述 符.信号驱动式IO就属于边缘触发。

epoll：即可以采用水平触发,也可以采用边缘触发。

1、水平触发

只有高电平或低电平的时候才触发

1-----高电平—触发
0-----低电平—不触发

#水平触发
#server服务端 
import socket
import select
sk=socket.socket()
sk.bind(("127.0.0.1",9904))
sk.listen(5)

while True:
    r,w,e=select.select([sk,],[],[],5)  #input输入列表，output输出列表，erron错误列表,5: 是监听5秒
    for i in r:   #[sk,]
        print("hello")

    print('>>>>>>')

#client客户端
import socket

sk=socket.socket()

sk.connect(("127.0.0.1",9904))

while 1:
    inp=input(">>").strip()
    sk.send(inp.encode("utf8"))
    data=sk.recv(1024)
    print(data.decode("utf8"))

2、边缘触发

1---------高电平--------触发

0---------低电平--------触发

IO多路复用优势：同时可以监听多个连接

示例：select可以监控多个对象

#server服务端 
#优势
import socket
import select
sk=socket.socket()
sk.bind(("127.0.0.1",9904))
sk.listen(5)
inp=[sk,]

while True:
    r,w,e=select.select(inp,[],[],5)  #[sk,conn]，5是每隔几秒监听一次

    for i in r:   #[sk,]
        conn,add=i.accept()  #发送系统调用
        print(conn)
        print("hello")
        inp.append(conn)
        # conn.recv(1024)
        conn.send('huhuhu'.encode('utf8'))
    print('>>>>>>')

#client客户端
import socket

sk=socket.socket()
sk.connect(("127.0.0.1",9904))

while 1:
    inp=input(">>").strip()
    sk.send(inp.encode("utf8"))
    data=sk.recv(1024)
    print(data.decode("utf8"))

多了一个判断，用select方式实现的并发

示例：实现并发聊天功能 (select+IO多路复用，实现并发）

#server服务端 
import socket
import select
sk=socket.socket()
sk.bind(("127.0.0.1",8801))
sk.listen(5)
inputs=[sk,]   # sk 只是用来监听新的链接对象
while True:  #监听sk和conn
    r,w,e=select.select(inputs,[],[],5) #conn发生变化,sk不变化就走else
    print(len(r))
    #判断sk or conn 谁发生了变化
    for obj in r:
        if obj==sk:
            conn,add=obj.accept()
            print(conn)
            inputs.append(conn)
        else:
            data_byte=obj.recv(1024)
            print(str(data_byte,'utf8'))
            inp=input('回答%s号客户>>>'%inputs.index(obj))
            obj.sendall(bytes(inp,'utf8'))

    print('>>',r)

#client客户端
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'))

Asynchronous I/O（异步IO）

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

异步最大特点：全程无阻塞

synchronous IO（同步IO)和asynchronous IO(异步IO)的区别：

A synchronous I/O operation causes the requesting process to be blocked until that I/O operationcompletes;
An asynchronous I/O operation does not cause the requesting process to be blocked;
两者的区别就在于synchronous IO做”IO operation”的时候会将process阻塞。（有一丁点阻塞，都是同步IO）按照这个定义，之前所述的blocking IO，non-blocking IO，IO multiplexing都属于synchronous IO（同步IO）。

同步IO：包括 blocking IO、non-blocking、select、poll、epoll（故:epool只是伪异步而已）（有阻塞）

异步IO：包括:asynchronous （无阻塞）

IO模型比较：

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

5、selectors模块应用

python封装好的模块：selectors
selectors模块: 会选择一个最优的操作系统实现方式

#select_module.py
import selectors
import socket

sel = selectors.DefaultSelector()  # 根据操作系统 选择IO多路径的方式

def accept(sock, mask):
    conn, addr = sock.accept()  # Should be ready
    print('accepted', conn, 'from', addr)
    conn.setblocking(False)  #设置成非阻塞
    sel.register(conn, selectors.EVENT_READ, read) #conn绑定的是read

def read(conn, mask):
	# 异常处理  客户端断开
    try:
        data = conn.recv(1000)  # Should be ready
        if not data:
            raise Exception
        print('echoing', repr(data), 'to', conn)
        conn.send(data)  # Hope it won't block
    except Exception as e:
        print('closing', conn)
        sel.unregister(conn)  #解除注册
        conn.close()

sock = socket.socket()
sock.bind(('localhost', 8090))
sock.listen(100)
sock.setblocking(False)

#注册   sock和accept 进行绑定
sel.register(sock, selectors.EVENT_READ, accept)

print("server....")


#循环监听
while True:
	#inputs=[sock,]   # sk 只是用来监听新的链接对象
	# 监听  相当与select.select(inputs,[],[])
    events = sel.select() 
    print("events",events)
    #拿到2个元素，一个key,一个mask
    for key, mask in events:
		#mask 一个掩码 没有实际的意义
        
        callback = key.data  # key.data 为绑定的函数，accept()或read()
        					 #当有新连接接入，callbalk=key.data=accept()    
        					 #原有链接发生变化时，callbalk=key.data=read()        
        # key.fileobj为socket 对象 
        # 新连接注册时：key.fileobj为socket
        # 原有的变化时：key.fileobj为客户端对象
        callback(key.fileobj, mask)   #key.fileobj=sock,conn1,conn2

import socket

sk=socket.socket()

sk.connect(("127.0.0.1",8090))

#循环监听
while 1:
    inp=input(">>>")
    sk.send(inp.encode("utf8")) #发送内容
    data=sk.recv(1024)  #接收信息
    print(data.decode("utf8"))  #打印出来