I/O 多路复用

首先这里只讲I/O多路复用中的epoll的用法，目的是为后续使用asyncio提前声明一些理论支撑。
对于一个I/O操作而言，它会涉及到两个系统对象，一个是调用这个IO的process (or thread)，另一个就是系统内核(kernel)。当一个read/recv读数据的操作发生时，该操作会经历两个阶段：
1）等待数据准备 (Waiting for the data to be ready)
2）将数据从内核拷贝到进程中(Copying the data from the kernel to the process)
正因为以上的物理条件，所以产生以下多种I/O模型：
1、阻塞IO（blocking IO）
2、非阻塞IO （nonblocking IO）
3、IO多路复用（IO multiplexing）
4、信号驱动IO（signal driven IO）
5、异步IO（asynchronous IO）
关于以上模型的介绍参阅这篇文章
一、阻塞IO(blocking IO)
服务器代码如下：

# !/usr/bin/python
import socket

HOST = '127.0.0.1'
PORT = 8888
# 定义socket类型，网络通信，TCP
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 套接字绑定的IP与端口
sock.bind((HOST, PORT))
# 开始TCP监听,监听5个请求
sock.listen(5)
while True:
    # 阻塞接受TCP连接，并返回新的套接字与IP地址
    conn, addr = sock.accept()
    while True:
        data = conn.recv(1024)
        if data:
            # processing client request
            conn.send('hello')
        else:
            # 关闭连接
            conn.close()  

从代码中可以看出服务器会阻塞等待，直到客户端发来新的请求，处理完毕后才能接收新的请求。
二、非阻塞IO （nonblocking IO）
服务器代码如下：

import socket

sock = socket.socket()
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
host = '127.0.0.1'
port = 8888
sock.bind((host, port))
sock.listen(5)

sock.setblocking(False)  # 设置不阻塞
r_list = []  # 用来存储所有来请求server端的conn连接
w_list = {}  # 用来存储所有已经有了请求数据的conn的请求数据

while True:
    try:
        conn, addr = sock.accept()  # 不阻塞，会报错
        if conn not in r_list:
            r_list.append(conn)  # 为了将连接保存起来，不然下次循环的时候，上一次的连接就没有了
    except (BlockingIOError, InterruptedError) as e:
        closed_done_list = []
        # 遍历读列表，依次取出套接字读取内容
        for conn in r_list:
            try:
                data = conn.recv(1024)  # 不阻塞，会报错
                if not data:  # 当一个客户端暴力关闭的时候，会接收到b''
                    conn.close()
                    closed_done_list.append(conn)
                    continue
                else:
                    # 记录所有的client的请求
                    w_list[conn] = data
            except (BlockingIOError, InterruptedError) as e:  # 没有收成功，则继续检索下一个套接字的接收
                continue
            except ConnectionResetError:
                conn.close()
                closed_done_list.append(conn)

        # 遍历写列表，依次取出套接字发送内容

        for conn, data in w_list.items():
            try:
                # processing client request
                conn.send(data)
                closed_done_list.append(conn)
            except (BlockingIOError, InterruptedError) as e:
                continue
        # 清除异常关闭或者已响应的client链接
        for conn in closed_done_list:
            if conn in w_list:
                w_list.pop(conn)
            if conn in r_list:
                r_list.remove(conn)

从代码中可以看出服务器跳过了阻塞等待接收客户端请求链接以及send/recv的过程，而是直接抛出异常，然后用户进程需要不断的主动询问kernel获取数据。
三、多路复用

import socket
import selectors


def handle_request(sock: socket.socket):  # 处理新连接
    conn, addr = sock.accept()
    slt.register(conn, selectors.EVENT_READ, data=handle_client_msg)


def handle_client_msg(sock: socket.socket):  # 处理消息
    data = sock.recv(1024)
    if data:
        print(data.decode())
    else:
        slt.unregister(sock)
        sock.close()


sock = socket.socket(family=socket.AF_INET, type=socket.SOCK_STREAM)
host = '127.0.0.1'
port = 8888
sock.bind((host, port))
sock.listen(5)
slt = selectors.DefaultSelector()
slt.register(fileobj=sock, events=selectors.EVENT_READ, data=handle_request)

while True:
    ready_events = slt.select(timeout=None)
    for event, _ in ready_events:
        # 使用各自的回调函数，分别处理不同的请求响应
        event.data(event.fileobj)

上面使用的是selectors自动根据系统的不同而选择适应的机制，slt.select会根据注册进去的events进行监听其状态，如果有I/O状态可读或是可写，则会返回相应的对象。