Python异步IO之select

1. select模块的基本使用（以socket为例）

# -*- coding:utf-8 -*-
# Author:Wong Du

import select
import socket
import queue

HOST_PORT = ("0.0.0.0", 9000)
print("33[31;1mServer Addr:{0}33[0m".format(HOST_PORT))

server = socket.socket()
server.bind(HOST_PORT)
server.listen(10)

inputs = [server, ]     # 监测服务端socket的活跃状态和新socket连接活跃状态列表
outputs = []            # 发送数据给客户端的socket连接列表
msg_queue = {}          # 发送给客户端的信息数据字典

# 断开socket连接函数
def disconnect():
    print("33[41;1mClient [{0}] disconnected...33[0m".format(r.getpeername()))
    if r in outputs:
        outputs.remove(r)   
    inputs.remove(r)  # 移除select监测连接
    del msg_queue[r]    # 删除消息队列



if __name__ == '__main__':
    while True:
        print("Waiting for socket to active...")

        # 如果在select监测的对象里没有活跃状态的socket，则卡在这里;
        # 当有活跃的socket对象时，把socket对象赋给readable,writeable,excetional;
        readable, writeable, exceptional = select.select(inputs, outputs, inputs)
        print("active connect:", readable, writeable, exceptional)

        for r in readable:  # 循环readable里活跃的socket对象
            if r is server: # 如果活跃的是server的socket对象，则代表有新客户端socket连接进来了
                conn, client_addr = server.accept()     # 接收client对象
                print("33[32;1mConnected client addr:{0}33[0m".format(client_addr))   # 打印连接进来的对象身份
                inputs.append(conn)                 # 加入到inputs列表让select监测处理
                msg_queue[conn] = queue.Queue()     # 接收到的客户端连接，不立即返回，暂存在队列里，以后发送
            else:   # 如果活跃的不是server的socket对象，则代表客户端socket有数据发过来了
                try:
                    data = r.recv(1024).decode()  # 接收客户端数据
                    if data:
                        # r.getpeername()获取客户端连接的身份信息
                        print("33[33;1mReceived [{0}] from the {1}33[0m".format(data, r.getpeername()))
                        if r not in outputs:
                            outputs.append(r)   # 把客户端连接加到outputs列表里
                        msg_queue[r].put(data.upper().encode()) # 把想要返回给客户端的数据放到相应的客户端连接队列里
                    else:
                        disconnect()    # 连接断开
                except ConnectionResetError as e:       # 抓取客户端断开错误
                    disconnect()        # 连接断开

        for w in writeable:
            # print("33[34;1mReading to send to client {0}33[0m".format(w.getpeername()))
            try:
                data = msg_queue[w].get_nowait()   # 获取队列中的数据
                w.send(data)        # 发送给客户端
                print("33[34;1mSend [{0}] to client {1}33[0m".format(data, w.getpeername()))
            except queue.Empty as e:
                print("No data to send to the client [{0}]".format(w.getpeername()))

            outputs.remove(w)   # 移除列表中需要发送数据的连接

        for e in exceptional:
            print("33[41;1mClient [{0}] handles exception33[0m".format(e.getpeername())) #select处理异常连接
            if e in outputs:
                outputs.remove(e)

            inputs.remove(e)
            del msg_queue[e]

# -*- coding:utf-8 -*-
# Author:Wong Du

import socket

HOST_PORT = ("localhost", 9000)
client = socket.socket()
client.connect(HOST_PORT)

while True:
    cmd = input("%s#" % HOST)
    if not cmd:
        continue
    client.send(cmd.encode())
    data = client.recv(1024)
    print(data.decode())

# -*- coding:utf-8 -*-
# Author:Wong Du

import socket
import time

server_addr = ("localhost", 9000)
client_socket = [socket.socket() for i in range(100)]

msg_data = "如果我是dj，你会爱我吗？"
count = 0


for client in client_socket:
    try:
        client.connect(server_addr)
        print("Success to connected...")
        client.send(msg_data.encode())
        data = client.recv(1024)
        print(data.decode())
        count += 1
    except ConnectionResetError:
        print(count)
time.sleep(10)

2. selector模块的基本使用（以socket为例）

# -*- coding:utf-8 -*-
# Author:Wong Du

import selectors
import socket, queue

sel = selectors.DefaultSelector()   # 生成一个sel对象
send_msg = {}                       # 返回信息列表

# 接收客户端连接函数
def accept(sock, mask):
    conn, client_addr = sock.accept()
    print("33[33;1mClient {0} is connected...33[0m".format(client_addr))
    # sock.setbloking(False)
    # 将客户端socket对象和read方法注册到sel里面
    sel.register(conn, selectors.EVENT_READ, read)
    send_msg[conn] = queue.Queue()

# 接收客户端发来数据函数
def read(r, mask):
    try:
        data = r.recv(1024).decode()
        if data:
            print("Received [{0}] from the client {1}".format(data, r.getpeername()))
            # conn.send(data.upper())
            send_msg[r].put(data.upper().encode())
            sel.modify(r, selectors.EVENT_WRITE, write)
        else:
            disconnect(r)
    except ConnectionResetError:
        disconnect(r)

# 发送数据给客户端函数
def write(w, mask):
    # print("33[34;1mReading to send to client {0}33[0m".format(w.getpeername()))
    try:
        data = send_msg[w].get_nowait()  # 获取队列中的数据
        w.send(data)  # 发送给客户端
        print("33[34;1mSend [{0}] to client {1}33[0m".format(data.decode(), w.getpeername()))
    except queue.Empty as e:
        print("No data to send to the client [{0}]".format(w.getpeername()))

    sel.modify(w, selectors.EVENT_READ, read)

# 断开socket连接函数
def disconnect(conn):
    print("33[41;1mClient {0} disconnected...33[0m".format(conn.getpeername()))
    sel.unregister(conn)
    conn.close()

# 初始化服务端连接
HOST_PORT = ("localhost", 20000)
server = socket.socket()
server.bind(HOST_PORT)
server.listen(10)
print("33[31;1mServer Address: {0}33[0m".format(HOST_PORT))
# 将服务端socket对象和accept方法注册到sel里面
sel.register(server, selectors.EVENT_READ, accept)

while True:
    # 开启事件监测(阻塞)，类似select的select.select(inputs, outputs, inputs),当有活跃连接时，
    # 返回一个元组，元组内有SelectorKey对象和events事件编号
    # SelectorKey对象内包含fileobj嵌套字对象，fd柄, events事件编号，data回调函数内存空间指针
    print("33[32;1mWaiting to connections...33[0m")
    events = sel.select()
    print("Active events: %s" % events)

    for key, mask in events:
        # 获取socket回调函数内存指针，即accept函数
        callback = key.data
        # 调用函数并把socket和events传进去
        callback(key.fileobj, mask)

# -*- coding:utf-8 -*-
# Author:Wong Du

import socket
HOST = "localhost"
Port = 20000
client = socket.socket()
client.connect((HOST, Port))

while True:
    cmd = input("%s#" % HOST)
    if not cmd:
        continue
    client.send(cmd.encode())
    data = client.recv(1024)
    print(data.decode())