Python之异步IO模型实现socket并发

服务端：

import socket
sk = socket.socket()
addr = ('127.0.0.1',8090)
sk.bind(addr)
sk.listen()
sk.setblocking(False) # 设置非阻塞模式,accept,recv等方法均不阻塞，而是抛出异常

conn_lst = [] # 建立一个列表存储接收到的连接
del_lst = [] # 建立一个列表存储已经关闭的连接
while True:
    try:
        conn,addr_client = sk.accept() # 没有连接时--BlockingIOError
        print('接收到一个连接') # 如果上一步没有异常发生，则表示收到一个连接
        conn_lst.append(conn) # 将接收到的连接放入列表中
    except BlockingIOError:
        for conn in conn_lst: # 循环接收到的连接,尝试接收消息
            try:
                msg = conn.recv(1024) # 如果没有收到，同样抛出异常--BlockingIOError
                if not msg: # 从一个关闭的客户端接收消息，收到的值为空
                    del_lst.append(conn) # 将已关闭的连接放入待删除列表中
                    continue
                print(msg)
            except BlockingIOError:
                for conn in del_lst: # 将客户端已关闭的连接关闭回收
                    conn.close()
                    conn_lst.remove(conn)
                del_lst.clear() # 清空已关闭的连接记录

客户端：

import socket
from threading import Thread
import time
def client():
    sk = socket.socket()
    addr = ('127.0.0.1',8090)
    sk.connect(addr)
    sk.send(b'hell0')
    sk.close()
if __name__ == '__main__': # 模拟20个客户端并发连接服务端
    for i in range(20):
        Thread(target=client).start()

弊端：while True循环模式极耗CPU,通常需要在循环中加入sleep，但是加入sleep影响实时性

IO多路复用模型-服务端

# 鉴于异步IO模型while True不停扫描高消耗CPU，所以采用IO多路复用模型
import select
import socket

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

read_lst = [sk]
while True:
    # select 监听请求对象，如果没有收到请求，则阻塞，此处相当于监听accept事件
    rret,wret,xret = select.select(read_lst,[],[]) # rret为响应事件对象，若响应accept事件,则返回sk,若响应recv,则返回conn
    # print(rret)
    for i in rret:
        if i is sk:
            conn,addr = i.accept()
            read_lst.append(conn)
        else:
            msg = i.recv(1024)
            if not msg:
                read_lst.remove(i)
                i.close()
                continue
            print(msg)