概述

select，poll，epoll 都是 IO 多路复用的机制。I/O 多路复用就是通过一种机制，可以监视多个描述符（socket, file, tunnel），一旦某个描述符就绪（一般是读就绪或者写就绪），能够通知程序进行相应的读写操作。

select 有 3 个缺点：

  1. 连接数受限，可以通过修改宏定义甚至重新编译内核的方式提升这一限制。
  2. 查找配对速度慢，调用select()会对所有socket进行一次线性扫描。
  3. 数据由内核拷贝到用户态

！！ poll改善了第一个缺点
！！！epoll改了三个缺点.

进一步解析

两种触发

select实现

select的调用过程如下所示：

select_activity.png

  1. 使用 copy_from_user 从用户空间拷贝 fd_set 到内核空间
  2. 注册回调函数 __pollwait
  3. 遍历所有 fd，调用其对应的 poll 方法（对于 socket，这个 poll 方法是 sock_poll，sock_poll 根据情况会调用到 tcp_poll , udp_poll 或者 datagram_poll）
  4. 以 tcp_poll 为例，其核心实现就是 __pollwait，也就是上面注册的回调函数。
  5. __pollwait 的主要工作就是把 current（当前进程）挂到设备的等待队列中，不同的设备有不同的等待队列，对于 tcp_poll 来说，其等待队列是 sk->sk_sleep （注意把进程挂到等待队列中并不代表进程已经睡眠了）。在设备收到一条消息（网络设备）或填写完文件数据（磁盘设备）后，会唤醒设备等待队列上睡眠的进程，这时 current 便被唤醒了。
  6. poll 方法返回时会返回一个描述读写操作是否就绪的 mask 掩码，根据这个 mask 掩码给 fd_set 赋值。
  7. 如果遍历完所有的 fd，还没有返回一个可读写的 mask 掩码，则会调用 schedule_timeout 是调用 select 的进程（也就是 current）进入睡眠。当设备驱动发生自身资源可读写后，会唤醒其等待队列上睡眠的进程。如果超过一定的超时时间（schedule_timeout 指定），还是没人唤醒，则调用 select 的进程会重新被唤醒获得CPU，进而重新遍历 fd，判断有没有就绪的 fd。
  8. 把 fd_set 从内核空间拷贝到用户空间。

poll实现

poll 的实现和 select 非常相似，只是描述 fd 集合的方式不同，poll 使用 pollfd 结构而不是 select 的 fd_set 结构，其他的都差不多。

epoll

相比于 select 和 poll，epoll 的改进可以归结为 2 点：

  1. epoll 和 poll 一样只告知那些就绪的文件描述符，而且当我们调用 epoll_wait() 获得就绪文件描述符时，返回的不是实际的描述符，而是一个代表就绪描述符数量的值，你只需要去 epoll 指定的一个数组中依次取得相应数量的文件描述符即可，这里也使用了内存映射（mmap）技术，这样便彻底省掉了这些文件描述符在系统调用时复制的开销

  2. 另一个本质的改进在于 epoll 采用基于事件的就绪通知方式。在 select/poll 中，进程只有在调用一定的方法后，内核才对所有监视的文件描述符进行扫描，而 epoll 事先通过 epoll_ctl() 来注册一个文件描述符，一旦基于某个文件描述符就绪时，内核会采用类似 callback 的回调机制，迅速激活这个文件描述符，当进程调用 epoll_wait() 时便得到通知

epoll 既然是对 select 和 poll 的改进，就应该能避免上述的三个缺点。那 epoll 都是怎么解决的呢？在此之前，我们先看一下 epoll 和 select 和 poll 的调用接口上的不同，select 和 poll 都只提供了一个函数—— select 或者 poll 函数。而epoll 提供了三个函数，epoll_create, epoll_ctl 和 epoll_wait，epoll_create 是创建一个 epoll 句柄；epoll_ctl 是注册要监听的事件类型；epoll_wait 则是等待事件的产生。

  1. 对于第一个缺点，epoll 的解决方案在 epoll_ctl 函数中。每次注册新的事件到 epoll 句柄中时（在 epoll_ctl 中指定 EPOLL_CTL_ADD），会把所有的 fd 拷贝进内核，而不是在 epoll_wait 的时候重复拷贝。epoll 保证了每个 fd 在整个过程中只会拷贝一次。

  2. 对于第二个缺点，epoll 的解决方案不像 select 或 poll 一样每次都把 current 轮流加入 fd 对应的设备等待队列中，而只在 epoll_ctl 时把 current 挂一遍（这一遍必不可少）并为每个 fd 指定一个回调函数，当设备就绪，唤醒等待队列上的等待者时，就会调用这个回调函数，而这个回调函数会把就绪的fd加入一个就绪链表）。epoll_wait 的工作实际上就是在这个就绪链表中查看有没有就绪的 fd（利用 schedule_timeout()实现睡一会，判断一会的效果，和 select 实现中的第7步是类似的）。

  3. 对于第三个缺点，epoll 没有这个限制，它所支持的 fd 上限是最大可以打开文件的数目，这个数字一般远大于2048,举个例子,在1GB内存的机器上大约是10万左右，具体数目可以 cat /proc/sys/fs/file-max 察看,一般来说这个数目和系统内存关系很大。

总结：

  1. select，poll 实现需要自己不断轮询所有 fd 集合，直到设备就绪，期间可能要睡眠和唤醒多次交替。而 epoll 其实也需要调用 epoll_wait 不断轮询就绪链表，期间也可能多次睡眠和唤醒交替，但是它是设备就绪时，调用回调函数，把就绪 fd 放入就绪链表中，并唤醒在 epoll_wait 中进入睡眠的进程。虽然都要睡眠和交替，但是 select 和 poll 在“醒着”的时候要遍历整个 fd 集合，而 epoll 在“醒着”的时候只要判断一下就绪链表是否为空就行了，这节省了大量的CPU时间。这就是回调机制带来的性能提升。

  2. select，poll 每次调用都要把 fd 集合从用户态往内核态拷贝一次，并且要把 current 往设备等待队列中挂一次，而 epoll 只要一次拷贝，而且把 current 往等待队列上挂也只挂一次（在 epoll_wait 的开始，注意这里的等待队列并不是设备等待队列，只是一个 epoll 内部定义的等待队列）。这也能节省不少的开销。

代码示例

select

这里为了来个实践，就以 python 语言为例，给个示例，因为 select 和 poll 差不多，这里就只给 select 的例子了，然后 epoll 也给一个，需要注意的是 epoll 只能在 Linux 的机器上使用，所以，重复实验的时候需要注意到这一点。

select_server.py

  1. #!/usr/bin/env python
  2. # encoding: utf-8
  3. import sys
  4. import cPickle
  5. import struct
  6. import socket
  7. import select
  8. import logging
  9. from threading import Event
  12. host = '0.0.0.0'
  13. port = 12007
  16. class SelectServer(object):
  17.     def __init__(self):
  18.         self.stop = Event()
  19.         self.server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  20.         self.server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
  21.         self.server.bind((host, port))
  22.         self.server.listen(10)
  24.     def send(self, channel, *args):
  25.         buffer = cPickle.dumps(args)
  26.         value = socket.htonl(len(buffer))
  27.         size = struct.pack('L', value)
  28.         channel.send(size)
  29.         channel.send(buffer)
  31.     def receive(self, channel):
  32.         size = struct.calcsize('L')
  33.         size = channel.recv(size)
  34.         try:
  35.             size = socket.ntohl(struct.unpack("L", size)[0])
  36.         except struct.error, e:
  37.             logging.error(e)
  38.             return ''
  39.         buf = ''
  40.         while len(buf) < size:
  41.             buf += channel.recv(size-len(buf))
  42.         return cPickle.loads(buf)[0]
  44.     def stop_server(self):
  45.         for output in self.outputs:
  46.             output.close()
  47.         self.stop.set()
  49.     def run(self):
  50.         inputs = [self.server, sys.stdin]
  51.         self.outputs = []
  52.         while not self.stop.is_set():
  53.             try:
  54.                 readable, writeable, exceptional = select.select(
  55.                     inputs, self.outputs, [])
  56.             except select.error, e:
  57.                 logging.error(e)
  58.                 break
  59.             for sock in readable:
  60.                 if sock == self.server:
  61.                     client, address = self.server.accept()
  62.                     text = self.receive(client)
  63.                     self.send(client, text)
  64.                     print("receive {} from {}".format(text, address))
  65.                     self.outputs.append(client)
  66.                     inputs.append(client)
  67.                 elif sock == sys.stdin:
  68.                     junk = sys.stdin.readline()
  69.                     if junk.strip() == 'stop':
  70.                         self.stop_server()
  71.                 else:
  72.                     try:
  73.                         data = self.receive(sock)
  74.                         if data:
  75.                             print("receive {} from {}".format(data, sock))
  76.                             self.send(sock, data)
  77.                         else:
  78.                             sock.close()
  79.                             inputs.remove(sock)
  80.                             self.outputs.remove(sock)
  81.                     except socket.error, e:
  82.                         logging.error(e)
  83.                         inputs.remove(sock)
  84.                         self.outputs.remove(sock)
  85.         self.server.close()
  87. if __name__ == "__main__":
  88.     SelectServer().run()

select_client.py

  1. #!/usr/bin/env python
  2. # encoding: utf-8
  3. import time
  4. import logging
  5. import random
  6. import struct
  7. import cPickle
  8. import socket
  11. host = '0.0.0.0'
  12. port = 12007
  14. class SelectClient(object):
  15.     def __init__(self):
  16.         self.clients = []
  17.         self.connections = 10
  19.     def send(self, channel, *args):
  20.         buffer = cPickle.dumps(args)
  21.         value = socket.htonl(len(buffer))
  22.         size = struct.pack('L', value)
  23.         channel.send(size)
  24.         channel.send(buffer)
  26.     def receive(self, channel):
  27.         size = struct.calcsize('L')
  28.         size = channel.recv(size)
  29.         try:
  30.             size = socket.socket.ntohl(struct.unpack("L", size)[0])
  31.         except struct.error, e:
  32.             logging.error(e)
  33.             return ''
  34.         buf = ''
  35.         while len(buf) < size:
  36.             buf += channel.recv(size-len(buf))
  37.         return cPickle.loads(buf)[0]
  39.     def run(self):
  40.         for i in xrange(self.connections):
  41.             client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  42.             client.connect((host, port))
  43.             self.clients.append(client)
  45.         for i in xrange(100):
  46.             idx = random.randint(0, 9)
  47.             self.send(self.clients[idx], 'message {}'.format(i))
  49.         time.sleep(10)
  51.         for client in self.clients:
  52.             client.close()
  54. if __name__ == '__main__':
  55.     SelectClient().run()

这一对 client 和 server 比较简单，就是服务器从客户端接收消息，然后再把消息打印出来，而客户端就 10 个客户端随机选择出来发送消息。如果不使用 select 的话，我们以前的通用操作方法可能是使用 threading 来进行多条线程监控多个 client，但是，这里使用 select 的话可以很简单得处理很多 client。

epoll_server.py

  1. #!/usr/bin/env python
  2. # encoding: utf-8
  3. import socket
  4. import select
  5. from threading import Event
  7. host = "0.0.0.0"
  8. port = 12008
  10. class EpollServer(object):
  11.     def __init__(self):
  12.         self.server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  13.         self.server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
  14.         self.server.bind((host, port))
  15.         self.server.listen(1)
  16.         self.server.setblocking(0)
  17.         self.server.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
  18.         self.epoll = select.epoll()
  19.         self.epoll.register(self.server.fileno(), select.EPOLLIN)
  20.         self.stop = Event()
  22.     def run(self):
  23.         try:
  24.             conns = {}
  25.             reqs = {}
  26.             resps = {}
  27.             while not self.stop.is_set():
  28.                 events = self.epoll.poll(1)
  29.                 for fileno, event in events:
  30.                     if fileno == self.server.fileno():
  31.                         conn, addr = self.server.accept()
  32.                         conn.setblocking(0)
  33.                         self.epoll.register(conn.fileno(), select.EPOLLIN)
  34.                         conns[conn.fileno()] = conn
  35.                         reqs[conn.fileno()] = b''
  36.                         resps[conn.fileno()] = "hello world"
  37.                     elif event & select.EPOLLIN:
  38.                         data = conns[fileno].recv(1024)
  39.                         print "receive data {} from {}".format(data, fileno)
  40.                         reqs[fileno] += data
  41.                         if len(data) < 1024:
  42.                             self.epoll.modify(fileno, select.EPOLLOUT)
  43.                     elif event & select.EPOLLOUT:
  44.                         bytes_writen = conns[fileno].send(resps[fileno])
  45.                         resps[fileno] = resps[fileno][bytes_writen:]
  46.                         if len(resps[fileno]) == 0:
  47.                             self.epoll.modify(fileno, select.EPOLLIN)
  48.                     elif event & select.EPOLLHUP:
  49.                         self.epoll.unregister(fileno)
  50.                         conns[fileno].close()
  51.                         del conns[fileno]
  52.         finally:
  53.             self.epoll.unregister(self.server.fileno())
  54.             self.epoll.close()
  55.             self.server.close()
  57. if __name__ == "__main__":
  58.     server = EpollServer()
  59.     server.run()

epoll_client.py

  1. #!/usr/bin/env python
  2. # encoding: utf-8
  3. import time
  4. import random
  5. import socket
  8. host = '0.0.0.0'
  9. port = 12008
  11. class SelectClient(object):
  12.     def __init__(self):
  13.         self.clients = []
  14.         self.connections = 10
  16.     def send(self, channel, data):
  17.         channel.send(data)
  19.     def receive(self, channel):
  20.         pass
  22.     def run(self):
  23.         for i in xrange(self.connections):
  24.             client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  25.             client.connect((host, port))
  26.             self.clients.append(client)
  28.         for i in xrange(100):
  29.             idx = random.randint(0, 9)
  30.             self.send(self.clients[idx], 'message {}'.format(i))
  32.         time.sleep(3)
  34.         for client in self.clients:
  35.             client.close()
  37. if __name__ == '__main__':
  38.     SelectClient().run()

这里的 epoll 和 select 的使用方式就不一样了，这里不再是传递一个 fd 列表了，而是给每个 fd register 一个关注的事件，是入事件还是出事件，然后根据 fd 和 event 来处理。需要注意的是，这里的 Python 代码和前面所说的底层实现有一点差别，例如没有 epoll_create 函数之类的，反之，而是 epoll.register 和 epoll.poll 之类的。

Reference