day42---几种network IO模型

I/O模型的简介

前置知识

"""
任务的提交方式
同步：就是发生功能调用时，需要等待任务的返回结果，期间不做任何操作。
异步：无需等待任务的返回结果，继续执行程序，任务的返回结果由异步回调机制返回。
任务的提交结果
阻塞：发生功能调用时（如I/O操作），会将当前线程挂起，直至得到返回结果，再将线程激活。
非阻塞：与阻塞的概念是相反的
"""

这里研究的I/O模型都是针对网络的I/O

5种I/O模型

"""
blocking I/O         阻塞I/O
nonblocking I/O      非阻塞I/O
I/O multiplexing     I/O多路复用
signal driven I/O    信号驱动I/O（不需要掌握）
asynchronous I/O     异步I/O
"""

对于一个Network I/O （以read为例），它会涉及到两个系统对象。一是调用这个I/O的process(or thread)，另一个是系统内核(kernel)。当一个read操作发生时，该操作会经历两个阶段。

(1)等待数据准备(waitting for data to ready)
(2)将数据从内核拷贝到进程中(copying the data from thekernel to the process)

阻塞I/O模型

在linux中，默认情况下所有的socket都是blocking。

blocking IO的特点就是在IO执行的两个阶段（等待数据和拷贝数据两个阶段）都被block了

import socket

IP_ADDRESS = ('0.0.0.0', 9090)

sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.bind(IP_ADDRESS)
sock.listen(5)

while True:
    conn, addr = sock.accept()
    while True:
        try:
            msg = conn.recv(1024)
            if not msg: break
            print(msg)
            conn.send(msg.upper())
        except ConnectionResetError as e:
            break
    conn.close()

在服务端开设多进程或者多线程 进程池线程池 其实还是没有解决IO问题。该等的地方还是得等 ，没有规避
只不过多个人等待的彼此互不干扰。

非阻塞I/O模型

在Linux下，可以设置socket使其变为nonblocking。

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

"""
服务端
"""
import socket
import time

IP_ADDRESS = ('0.0.0.0', 9090)

sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.bind(IP_ADDRESS)
sock.listen(5)

# 将network IO由阻塞变为非阻塞
sock.setblocking(False)
read_list = []
del_list = []

while True:
    try:
        conn, addr = sock.accept()
        read_list.append(conn)
    except BlockingIOError as e:
        """
        非阻塞模式下，没有阻塞状态，若没有连接进来会报错
        """
        # time.sleep(0.01)
        for conn in read_list:
            try:
                recv_data = conn.recv(1024)
                if not recv_data:
                    conn.close()
                    del_list.append(conn)
                    continue
                print(recv_data.decode('utf-8'))
                conn.send(recv_data.upper())
            except BlockingIOError as e:
                continue
            except ConnectionResetError as e:
                conn.close()
                del_list.append(conn)
        """
        去掉无用的连接
        """
        for conn in del_list:
            read_list.remove(conn)
        read_list.clear()
"""
客户端
"""
import socket

IP_ADDRESS = ('182.92.59.34', 9090)

client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client.connect_ex(IP_ADDRESS)

while True:
    # msg = input('please enter the message>>>:').strip()
    # if not msg: continue
    client.send(b'hello world!')
    back_msg = client.recv(1024)
    print(back_msg.decode('utf-8'))

但是非阻塞IO模型绝不被推荐。

因为长时间占用着CPU并且不干活 让CPU不停的空转，我们实际应用中也不会考虑使用非阻塞IO模型。

I/O多路复用

"""
当用户进程调用了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的优势在于可以处理多个连接，不适用于单个连接

"""
服务端
"""
import socket
import select

IP_ADDRESS = ('0.0.0.0', 9090)

sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.bind(IP_ADDRESS)
sock.listen(5)

sock.setblocking(False)
read_list = [sock, ]
write_list = []
wdata = {}

while True:
    r_list, w_list, x_list = select.select(read_list, write_list, [])
    for item in r_list:
        """
        针对不同的对象，做不同的处理，r_list里面可能是socket对象，也可能是conn对象
        """
        if item is sock:
            conn, addr = item.accept()
            """将conn加入到监管队列中去"""
            read_list.append(conn)
        else:
            try:
                msg = item.recv(1024)
                if not msg:
                    item.close()
                    read_list.remove(item)
                    continue
                print(msg.decode('utf-8'))
                write_list.append(item)
                wdata[item] = msg.upper()
            except Exception:
                item.close()
                read_list.remove(item)

    for item in w_list:
        item.send(wdata[item])
        write_list.remove(item)
        wdata.pop(item)
        
"""
客户端
"""
import socket

IP_ADDRESS = ('182.92.59.34', 9090)

client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client.connect_ex(IP_ADDRESS)

while True:
    # msg = input('please enter the message>>>:').strip()
    # if not msg: continue
    client.send(b'hello world!')
    back_msg = client.recv(1024)
    print(back_msg.decode('utf-8'))

总结：

"""
监管机制其实有很多
select机制  windows linux都有

poll机制    只在linux有   poll和select都可以监管多个对象 但是poll监管的数量更多

上述select和poll机制其实都不是很完美 当监管的对象特别多的时候
可能会出现 极其大的延时响应

epoll机制   只在linux有
	它给每一个监管对象都绑定一个回调机制
	一旦有响应 回调机制立刻发起提醒

针对不同的操作系统还需要考虑不同检测机制 书写代码太多繁琐
有一个人能够根据你跑的平台的不同自动帮你选择对应的监管机制
selectors模块
"""

异步I/O

"""
异步IO模型是所有模型中效率最高的 也是使用最广泛的
相关的模块和框架
	模块:asyncio模块
	异步框架:sanic tronado twisted
		速度快！！！
"""

import threading
import time
import asyncio


async def hello():
    print(f'hello world {threading.current_thread().getName()}')
    """使用sleep来模拟IO操作"""
    time.sleep(1)
    print(f'hello world {threading.current_thread().getName()}')


loop = asyncio.get_event_loop()
task = [hello(), hello()]
loop.run_until_complete(asyncio.wait(task))
loop.close()

注意：

"@coroutine" decorator is deprecated since Python 3.8, use "async def" instead

I/O模型的比较分析

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

selectors模块

select,poll,epoll