PythonIO多路复用

python IO 多路复用 select poll epoll

select

select原理

select是通过系统调用来监视着一个由多个文件描述符组成的数组，当select()返回后，数组中就绪的文件描述符会被内核修改标记位，使得进程可以获得这些文件描述符从而进行后续的读写操作。select是通过遍历来监视整个数组的，而且每次遍历都是线性的。

select优点

select目前几乎在所有的平台上支持，良好的跨平台性。

select缺点

• 每次调用select，都需要把fd集合从用户态拷贝到内核态，这个开销在fd很多的时候会很大。
• 单个进程能够监视的fd数量存在最大限制，在linux上默认为1024（可以通过修改宏定义或者重新编译内核的方式提升这个限制）
• 并且由于select的fd是放在数组中，并且每次都要线性遍历整个数组，当fd很多的时候，开销也很大。

python select

调用select的函数为r,w,e = select.select(rlist,wlist,xlist[, timeout]),前三个参数都分别是三个列表，数组中的对象均为waitable object：均是整数的文件描述符（file descriptor）或者 一个拥有返回文件描述符方法fileno()的对象：

• rlist：等待读就绪的list
• wlist：等待写就绪的list
• errlist：等待“异常”的list

select方法用来监视文件描述符，如果文件描述符发生变化，则获取该描述符。

1. 这三个list可以是一个空的list，但是接收3个空的list是依赖于系统的（在linux上是可以接受的，在windows上不可以）
2. 当rlist序列中的描述符发生可读时（accept和read）

服务器代码

import select
import socket
from queue import Queue

from time import sleep

server = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
server.setblocking(False)

server_address = ("localhost",8090)
print("starting up on %s port %s" % server_address)

server.bind(server_address)

server.listen(5)
inputs = [server]
outputs = []
message_queues= {}

while inputs:
    print("waiting for the next event.")

    readable,writable,exceptional = select.select(inputs, outputs, inputs)
    # 循环判断是否由客户端连接进来，当有客户端连接进来时select将触发
    for s in readable:
        # 判断当前触发的是不是服务端对象，当触发的对象服务端对象，说明有新客户端连接上来了
        # 表示有新用户连接
        if s is server:
            connection,client_address = s.accept()
            print("connection from",client_address)
            connection.setblocking(0)
            # 将客户端对象也加入到监听的列表中，当客户端发送消息时 select将触发
            inputs.append(connection)
            # 为连接的客户端单独创建一个消息队列，用来保存客户端发送的消息
            message_queues[connection] = Queue()
        else:
            # 有老用户发消息，处理
            data = s.recv(1024)
            # 客户端未断开
            if data != b"":
                print("received %s from %s"%(data,s.getpeername()))
                message_queues[s].put(data)
                if s not in outputs:
                    outputs.append(s)
            else:
                if s in outputs:
                    outputs.remove(s)
                inputs.remove(s)
                s.close()
                del message_queues[s]
    for s in writable:
        try:
            message_queue = message_queues.get(s)
            send_data = ""
            if message_queue is not None:
                send_data = message_queue.get_nowait()
            else:
                print("客户端断开了")
        except Queue.empty():
            print("客户端断开了")
            outputs.remove(s)
        else:
            if message_queue is not None:
                s.send(send_data)
            else:
                print("hash closed")

    # 处理异常情况
    for s in exceptional:
        inputs.remove(s)
        if s in outputs:
            outputs.remove(s)
        s.close()
        del message_queues[s]
    sleep(1)

客户端代码

import socket
messages = ['This is the message ', 'It will be sent ', 'in parts ', ]

server_address = ('localhost', 8090)

# Create aTCP/IP socket

socks = [socket.socket(socket.AF_INET, socket.SOCK_STREAM), socket.socket(socket.AF_INET,  socket.SOCK_STREAM), ]

# Connect thesocket to the port where the server is listening

print ('connecting to %s port %s' % server_address)
# 连接到服务器
for s in socks:
    s.connect(server_address)

for index, message in enumerate(messages):
    # Send messages on both sockets
    for s in socks:
        print ('%s: sending "%s"' % (s.getsockname(), message + str(index)))
        s.send(message.encode('utf8'))
    # Read responses on both sockets

for s in socks:
    data = s.recv(1024)
    print ('%s: received "%s"' % (s.getsockname(), data))
    if data != "":
        print ('closingsocket', s.getsockname())
        s.close()

poll

poll的原理

poll本质上和select没有区别，只是没有了最大连接数（linux上默认1024个）的限制，原因是它基于链表存储的。

poll的缺点

poll除了没有最大连接数的缺点，其他都和select一样。

在python中调用poll

• select.poll(),返回一个poll对象，支持注册和注销文件描述符
• poll.registed(fd[,eventmask]) 注册一个文件描述符，注册后，可以通过poll()方法来检查是否由对应的I/O事件发生。fd可以是i个整数，或者有返回的整数的filenoe()方法对象。如果File对象实现了fileno()，也可以当做参数使用。
• eventmask是一个你想去检查的时间类型，它可以是常量POLLIN，POLLPRI和POLLOUT的组合。如果缺省，默认会去检查所有的3种事件类型
  • POLLIN：有数据读取
  • POLLPRT：有数据紧急读取
  • POLLOUT：准备输出：输出不会阻塞
  • POLLERR：某些错误情况出现
  • POLLHUB：挂起
  • POLLNVAL：无效请求，描述无法打开
• poll.modify(fd,eventmask)修改一个已经存在的fd，和poll.register(fd,eventmask)有相同的作用。如果去尝试修改一个未经注册的fd，会引起一个errno为ENOENT的IOError
• poll.unregister(fd)从poll对象中注销一个fd。尝试去注销一个未经注册的fd，会引起KeyError
• poll.poll([timeout])去检测已经注册了的文件描述符。会返回一个可能为空的list，list中包含着(fd,event)这样的二元祖。fd是文件描述符，event是文件描述符对应的时间。如果返回是一个空的list，则说明了超时了且没有文件描述符有事件发生。timeout的单位是milliseconds，如果设置了timeout，系统将会等待对应的时间。如果timeout缺省或者是None，这个方法将会阻塞知道对应的poll对象有时间发生。

import select

def create_srv_socket(address):
    '''建立并返回一个服务器监听socket'''
    listener = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
    listener.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
    listener.bind(address)
    listener.listen(64)
    print("Listening at  {}".format(address))
    return listener

def all_events_forever(poll_object):
    while True:
        for fd,event in poll_object.poll():
            yield fd,event

def serve(listener):
    sockets = {listener.fileno():listener} # 创建一个字典保存所有的sock
    addresses = {}
    bytes_received = {} # 缓存接受的数据
    bytes_to_send = {} # 缓存发送的数据

    poll_object = select.poll()
    poll_object.register(listener,select.POLLIN) # 注册一个读取的poll对象

    for fd,event in all_events_forever(poll_object): # 利用生成器，去读描述符和事件
        sock = socket[fd] # 取得sock
        if event & (select.POLLHUB |select.POLLERR | select.POLLNVAL) # 如果事件是挂起、错误或无效请求，则删除
            address = addresses.pop(sock)
            rb = bytes_received.pop(sock,b"")
            sb = bytes_to_send.pop(sock,b"")
            if rb:
                print("Client {} send {} but then closed".format(address,rb))
            elif sb:
                print("Client {} closed before we send {}".format(address,sb))
            else:
                print("Client {} closed socket normally".format(address))
            poll_object.unregister(fd) # 注销一个fd
            del sockets[fd]
        elif sock is listener: # 如果有监听者事件，说明有新的客户端连接
            sock,address = sock.accept()
            print("Accepted connection from {}".format(address))
            sock.setblocking(False)
            sockets[sock.fileno()] = sock
            address[sock] = address
            poll_object.register(sock,select.POLLIN)
        elif event & select.POLLIN: # 如果有读事件
            more_data = sock.recv(4096)
            if not mort_data: # 数据读完了
                sock.close()
                continue
            data = bytes_received.pop(sock,b"") +more_data
            if data.endswith(b"?"):
                bytes_to_send[sock] = data
                poll_object.modify(sock,select.POLLOUT) # 读完了改成写
            else:
                bytes_received[sock] = data
        elif event & select.POLLOUT:
            data = bytes_to_send.pop(sock)
            n = sock.send(data)
            if n <len(data):
                bytes_to_send[sock] = data[n:] 
            else：
                poll_object.modify(sock,select.POLLIN)
if __main__ == "__main__":
    address = 
    listener = create_srv_socket(address)
    server(listener)

epoll

epoll的原理与改进

在linux由内核直接支持的方法。epoll解决了select和poll的缺点。

• 对于第一个缺点，epoll的解决方法是每次注册新的事件到epoll中，会把所有的fd拷贝进内核，而不是在等待的时候重新拷贝，保证了每个fd在整个过程中只会拷贝1次。
• 对于第二个缺点，epoll没有这个限制，它所支持的fd上限是最大可以打开文件的数据，具体 数据可以cat /proc/sys/fs/file_max查看，一般来说这个数目和系统内存关系比较大。
• 对于第三个缺点，epoll的解决方法不像select和poll每次对所有fd进行遍历轮询所有fd集合，而是在注册新的事件时，为每个fd指定一个回调函数，当设备就绪的时候，调用这个回调函数，这个回调函数就会把就绪的fd加入一个就绪表中。所以epoll只需要遍历就绪表

epoll同时支持水平触发和边缘触发：

• 水平触发：只要满足条件，就触发一个事件（只要有数据没有被获取，内核就不断通知你）。例如：在水平触发模式下，重复调用epoll.poll()会重复通知关注的event，直到与该even有关的所有数据都已被处理。
• 边缘触发：每当状态变化时，触发一个事件。例如：在边缘触发模式中，epoll.poll()在读或者写event在socket上发生后，将只会返回一次event。调用epoll.poll()的程序必须处理所有的和这个event相关的数据，随后的epoll.poll()调用不会再有这个event的通知。