Python_阻塞IO、非阻塞IO、IO多路复用

0、承上

　　进程：

　　　　计算机里最小的资源分配单位；

　　　　数据隔离， 利用多核，数据不安全。

　　线程：

　　　　计算机中最小的CPU调度单位；

　　　　数据共享，GIL锁,数据不安全.

　　协程:

　　　　线程的一部分,是有用户来调度的;

　　　　数据共享,数据安全.

　　异步:  同时做不止一件事情.

　　同步:  事情一件接着一件 的做.

　　阻塞:  recv、recvfrom、accept、sleep、input

　　非阻塞：平时遇见的处过上边基本上都是。

　　IO操作：

　　　　网络相关的操作

　　　　文件处理、json.dump/load、logging、print、input、recv/send、connect/accept、recvfrom/sendto

　　recv为什么要阻塞？

　　　　等待数据到来到Python程序的内存中。

　　IO模型一共有五种，由于信号驱动IO不常用，我们这里主要介绍阻塞IO、非阻塞IO、IO多路复用以及异步IO。

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

　　　　(1)  等待数据准备( Waiting for the data to be ready )

　　　　(2)  将数据从内核拷贝到进程中( Copying the data from the kernel to the process )

　　这些IO模型的区别就在这两个阶段上各有不同.

1、阻塞IO( Blocking IO )

　　在Linux中,默认情况下所有的socket都是blocking读操作流程大概如下:

 import socket

 sk = socket.socket()
 sk.setblocking(True)

 # True  阻塞
 # False  非阻塞
 # TCP协议的socket sever不能同时接收多个请求
 # sk.accept()
 # while True:
 #     conn.recv()

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

　　非阻塞的形式实现了并发的socket server.

　　非阻塞的形式实现了并发的socket sever,太耗CPU.

　　没有数据来的时候程序的高速处理极大地占用了CPU资源.

 import socket

 sk = socket.socket()
 sk.bind(('127.0.0.1', 9000))
 sk.setblocking(False)
 sk.listen()
 conn_lst = []
 del_lst = []
 while True:
     try:
         conn,addr = sk.accept() # 非阻塞,没有连接来就报错
         conn_lst.append(conn)
         print(conn)
     except BlockingIOError:
         for con in conn_lst:
             try:
                 con.send(b'hello')
                 try:
                     print(con.recv(1024))   # 非阻塞 没有消息来就报错
                 except BlockingIOError: # 没有消息就报错
                     pass
             except ConnectionResetError:    # send没有连接的报错
                 con.close()
                 del_lst.append(con)
         for con in del_lst:
             conn_lst.remove(con)
         del_lst.clear()

服务器端

 import socket

 sk = socket.socket()
 sk.connect(('127.0.0.1', 9000))
 while True:
     print(sk.recv(1024))
     sk.send(b'bye')
 sk.close()

客户端

　　sever:

结果:

D:\Python36\python.exe E:/Python/草稿纸0.py
<socket.socket fd=268, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('127.0.0.1', 9000), raddr=('127.0.0.1', 51839)>
b'bye'
b'byebye'
b'bye'
b'bye'
b'bye'
b'bye'
b'bye'
b'bye'
b'bye'
b'bye'
b'bye'
b'bye'
b'bye'
b'bye'
b'bye'
b'bye'
b'bye'
b'bye'
b'bye'
b'bye'
b'bye'
b'bye'
b'bye'
b'bye'
b'bye'
b'bye'
b'bye'
b'bye'
b'bye'
b'bye'
b'bye'
b'bye'
b'byebye'
b'bye'
b'bye'
b'bye'
b'byebye'
b'bye'
b'bye'
b'bye'
b'bye'

Process finished with exit code 1

服务器端

D:\Python36\python.exe E:/Python/草稿纸.py
b'hello'
b'hello'
b'hello'
b'hello'
b'hello'
b'hello'
b'hello'
b'hello'
b'hello'
b'hello'
b'hello'
b'hello'
b'hello'
b'hello'
b'hello'
b'hello'
b'hello'
b'hello'
b'hello'
b'hello'
b'hello'
b'hello'
b'hello'
b'hello'
b'hello'
b'hello'
b'hello'
b'hello'
b'hello'
b'hello'
b'hellohellohello'
b'hello'
b'hello'
b'hellohellohello'
b'hello'
b'hello'
b'hellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohellohello'
b'hellohello'
b'hello'

客户端结果

　　由于通信的一直是小数据块(大小不够1024),出现了黏包现象.

3、IO多路复用(IO multiplexing)

 import select
 import socket

 sk = socket.socket()
 sk.bind(('127.0.0.1', 9000))
 sk.setblocking(False)
 sk.listen()

 rlst = [sk] # 监听的是对象的读操作
 wlst = []   # 监听的是对象的写操作
 xlst = []   # 监听的是对象的异常操作
 while True:
     rl,wl,xl = select.select(rlst, wlst, xlst)
     for obj in rl:
         if obj == sk:
             conn,addr = sk.accept()
             rlst.append(conn)
         else:
             msg = obj.recv(1024)
             if msg == b'':
                 obj.close()
                 rlst.remove(obj)
                 continue
             print(msg)
             obj.send(b'hello')

IO多路复用-sever端

 import socket

 sk = socket.socket()
 sk.connect(('127.0.0.1', 9000))
 while True:
     sk.send(b'wahaha')
     print(sk.recv(1024))
 sk.close()

IO多路复用-client端

　　socketsever —— TCP协议的并发操作  selectors + 多线程

　　IO多路复用的select的工作机制

　　　　select　　Windows　　轮询

　　　　poll　　    Linux　　      轮询，poll能够监听的对象比select要多

　　　　epoll　　  Linux　　      不是采用轮询的方式，而是采用回调函数的形式