Linux下I/O多路复用select, poll, epoll 三种模型

select, poll, epoll本质上都是同步的I/O，因为它们都是在读写事件就绪后自己负责进行读写，这个读写的过程是阻塞的。

select, poll, epoll 都是一种 I/O 复用的机制。它们都是通过一种机制（由系统提供的）来监视多个描述符，一旦某个描述符就绪了，就能通知程序进行相应的读写操作。

select

select的原理

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

select的缺点

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

在Python中调用select

Python中，select，poll，epoll和unix的kqueue()都在模块select中。

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

• rlist: 等待读就绪的list
• wlist: 等待写就绪的list
• xlist: 等待“异常”的list

这三个list可以是一个空的list，但是接收3个空的list是依赖于系统的(在Linux上是可以接受的，但是在window上是不可以的)。

timeout参数是接受一个 float 的数字，单位是秒。当缺省timeout时，select会一直阻塞之道至少有一个文件描述符(fd)准备就绪。如果timeout设为0时，则select不会阻塞。

函数的返回值是返回三个准备就绪的list: 对应者rlist, wlist, xlist这三个list的子集。如果timeout，会返回3个空的list。

在list中可以接受Ptython的的file对象(比如sys.stdin，或者会被open()和os.open()返回的object)，socket object将会返回socket.socket()。也可以自定义类，只要有一个合适的fileno()的方法(需要真实返回一个文件描述符，而不是一个随机的整数)。

Python的简单示例

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import select, socket

response = b"hello world"

#创建一个server socket
serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
serversocket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
serversocket.bind(('localhost', 8080))
serversocket.listen(1)
serversocket.setblocking(0)

inputs = [serversocket, ]

while True:
    rlist, wlist, xlist = select.select(inputs, [], [])
    for sock in rlist:
        ＃ server socket读就绪
        if sock == serversocket:
            con, addr = serversocket.accept()
            ＃将这个connection添加到读就绪中
            inputs.append(con)
        else:
            data = sock.recv(1024)
            if data:
                sock.send(response)
                ＃从读就绪的list中删除
                inputs.remove(sock)
                sock.close()

poll

poll的原理

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

poll的缺点

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

在Python中调用poll

• select.poll()，返回一个poll的对象，支持注册和注销文件描述符。

• poll.register(fd[, eventmask])注册一个文件描述符，注册后，可以通过poll()方法来检查是否有对应的I/O事件发生。fd可以是i 个整数，或者有返回整数的fileno()方法对象。如果File对象实现了fileno()，也可以当作参数使用。

• eventmask是一个你想去检查的事件类型，它可以是常量POLLIN, POLLPRI和 POLLOUT的组合。如果缺省，默认会去检查所有的3种事件类型。

事件常量	意义
POLLIN	有数据读取
POLLPRT	有数据紧急读取
POLLOUT	准备输出:输出不会阻塞
POLLERR	某些错误情况出现
POLLHUP	挂起
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对象有一个事件发生。

Python简单示例

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import select, socket

response = b"hello world"

serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
serversocket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
serversocket.bind(('192.168.199.197', 8080))
serversocket.listen(1)
serversocket.setblocking(0)

#
poll = select.poll()
poll.register(serversocket.fileno(), select.POLLIN)

connections = {}
while True:
    for fd, event in poll.poll():
        if event == select.POLLIN:
            if fd == serversocket.fileno():
                con, addr = serversocket.accept()
                poll.register(con.fileno(), select.POLLIN)
                connections[con.fileno()] = con
            else:
                con = connections[fd]
                data = con.recv(1024)
                if data:
                    poll.modify(con.fileno(), select.POLLOUT)
        elif event == select.POLLOUT:
            con = connections[fd]
            con.send(response)
            poll.unregister(con.fileno())
            con.close()

epoll

epoll的原理及改进

在linux2.6（准确来说是2.5.44）由内核直接支持的方法。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同时支持水平触发和边缘触发：

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

在Python中调用epoll

• select.epoll([sizehint=-1])返回一个epoll对象。

• eventmask

事件常量	意义
EPOLLIN	读就绪
EPOLLOUT	写就绪
EPOLLPRI	有数据紧急读取
EPOLLERR	assoc. fd有错误情况发生
EPOLLHUP	assoc. fd发生挂起
EPOLLRT	设置边缘触发(ET)（默认的是水平触发）
EPOLLONESHOT	设置为 one-short 行为，一个事件(event)被拉出后，对应的fd在内部被禁用
EPOLLRDNORM	和 EPOLLIN 相等
EPOLLRDBAND	优先读取的数据带(data band)
EPOLLWRNORM	和 EPOLLOUT 相等
EPOLLWRBAND	优先写的数据带(data band)
EPOLLMSG	忽视

• epoll.close()关闭epoll对象的文件描述符。
• epoll.fileno返回control fd的文件描述符number。
• epoll.fromfd(fd)用给予的fd来创建一个epoll对象。
• epoll.register(fd[, eventmask])在epoll对象中注册一个文件描述符。（如果文件描述符已经存在，将会引起一个IOError）
• epoll.modify(fd, eventmask)修改一个已经注册的文件描述符。
• epoll.unregister(fd)注销一个文件描述符。
• epoll.poll(timeout=-1[, maxevnets=-1])等待事件，timeout(float)的单位是秒（second）。

Ptython示例

epoll的示例就直接引用这篇出名的blog了

import socket, select

EOL1 = b'\n\n'
EOL2 = b'\n\r\n'
response  = b'HTTP/1.0 200 OK\r\nDate: Mon, 1 Jan 1996 01:01:01 GMT\r\n'
response += b'Content-Type: text/plain\r\nContent-Length: 13\r\n\r\n'
response += b'Hello, world!'

serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
serversocket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
serversocket.bind(('0.0.0.0', 8080))
serversocket.listen(1)
serversocket.setblocking(0)

epoll = select.epoll()
epoll.register(serversocket.fileno(), select.EPOLLIN)

try:
   connections = {}; requests = {}; responses = {}
   while True:
      events = epoll.poll(1)
      for fileno, event in events:
         if fileno == serversocket.fileno():
            connection, address = serversocket.accept()
            connection.setblocking(0)
            epoll.register(connection.fileno(), select.EPOLLIN)
            connections[connection.fileno()] = connection
            requests[connection.fileno()] = b''
            responses[connection.fileno()] = response
         elif event & select.EPOLLIN:
            requests[fileno] += connections[fileno].recv(1024)
            if EOL1 in requests[fileno] or EOL2 in requests[fileno]:
               epoll.modify(fileno, select.EPOLLOUT)
               print('-'*40 + '\n' + requests[fileno].decode()[:-2])
         elif event & select.EPOLLOUT:
            byteswritten = connections[fileno].send(responses[fileno])
            responses[fileno] = responses[fileno][byteswritten:]
            if len(responses[fileno]) == 0:
               epoll.modify(fileno, 0)
               connections[fileno].shutdown(socket.SHUT_RDWR)
         elif event & select.EPOLLHUP:
            epoll.unregister(fileno)
            connections[fileno].close()
            del connections[fileno]
finally:
   epoll.unregister(serversocket.fileno())
   epoll.close()
   serversocket.close()