利用epoll实现异步IO

　　之前异步IO一直没搞明白，大致的理解就是在一个大的循环中，有两部分：第一部分是监听事件；第二部分是处理事件（通过添加回调函数的方式）。就拿网络通信来说，可以先通过调用 select 模块中的 select 监听各个 socket 。当 socket 有事件到来时，针对相应的事件做出处理，就这么一直循环下去。所以异步IO也被称为事件驱动IO。原理其实我说得太简单了，所以我会以一个例子来说明一切。不过在这之前我还是要说一下 select 和 epoll 的区别。

一、IO多路服用的select

　　IO多路复用相对于阻塞式和非阻塞式的好处就是它可以监听多个 socket ，并且不会消耗过多资源。当用户进程调用 select 时，它会监听其中所有 socket 直到有一个或多个 socket 数据已经准备好，否则就一直处于阻塞状态。select的缺点在于单个进程能够监视的文件描述符的数量存在最大限制，select()所维护的存储大量文件描述符的数据结构，随着文件描述符数量的增大，其复制的的开销也线性增长。同时，由于网络响应时间的延迟使得大量的tcp链接处于非常活跃状态，但调用select()会对所有的socket进行一次线性扫描，所以这也浪费了一定的开销。不过它的好处还有就是它的跨平台特性。

二、 异步IO的epoll

　　epoll的优点就是完全的异步，你只需要对其中 poll 函数注册相应的 socket 和事件，就可以完全不管。当有时间发生时，数据已经从内核态拷贝到用户态，也就是完全没有阻塞。

三、基于epoll的聊天室程序

　　说了这么多，我决定还是用epoll写一个多人聊天程序。epoll可以支持大量连接，select却有限制，所以这就是我决定用epoll的原因。首先看服务器程序：

 import socket, select
 # 服务端

 serverSock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 serverSock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, True)
 serverSock.bind(('127.0.0.1', 8001))
 serverSock.listen(5)
 serverSock.setblocking(False)

 EOL = bytes('\n\n', 'utf-8')
 QUIT = bytes('\r\n', 'utf-8')
 epoll = select.epoll()
 epoll.register(serverSock.fileno(), select.EPOLLIN)
 print('注册事件：%s'%serverSock.fileno())

 try:
     connections = {}; requests = {}; responses = {}
     while True:
         events = epoll.poll(1)
         for fileno, event in events:
 #             print('event:%s fileno:%s'%(event, fileno))
             if fileno == serverSock.fileno():
                 clientSock, address = serverSock.accept()
                 print('连接到客户端： %s：%s'%(address[0], address[1]))
                 clientSock.setblocking(False)
                 connections[clientSock.fileno()] = (clientSock, address)
                 epoll.register(clientSock.fileno(), select.EPOLLOUT) # socket只能注册输入或输出一个，不能同时注册
                 requests[clientSock.fileno()] = bytes('', 'utf-8')
                 responses[clientSock.fileno()] = bytes('你已连接到服务器,IP为{}:{}\n\n'.format(*serverSock.getsockname()),
                                          'utf-8')
             elif event & select.EPOLLIN:
                 requests[fileno] += connections[fileno][0].recv(1024)
                 if requests[fileno].endswith(EOL):
                     msg = str(requests[fileno], 'utf-8')
                     msg = '来自{}的消息：{}'.format(connections[fileno][1], msg[:-2])
                     requests[fileno] = b''
                     #print(msg)
                     for i in responses:
                         if i == fileno:
                             continue
                         responses[i] += bytes(msg, 'utf-8')
                         epoll.modify(i, select.EPOLLOUT)
                 if QUIT in requests[fileno]:
                     epoll.modify(fileno, select.EPOLLOUT) 

             elif event & select.EPOLLOUT:
                 #print('开始发送消息：%s'%str(responses[fileno], 'utf-8'))
                 bytesSend = connections[fileno][0].send(responses[fileno])
                 responses[fileno] = responses[fileno][bytesSend:]
                 #print('发送完成')
                 if responses[fileno] == b'':
                     epoll.modify(fileno, select.EPOLLIN)
                 if QUIT in requests[fileno]:
                     epoll.modify(fileno, 0)
                     connections[fileno][0].shutdown(socket.SHUT_RDWR)

             elif event & select.EPOLLHUP:
                 epoll.unregister(fileno)
                 connections[fileno][0].close()
                 del connections[fileno]
 finally:
     epoll.unregister(serverSock.fileno())
     epoll.close()
     serverSock.close()
     print('已退出服务端程序')

注意，我首先定义了两个终止符：EOL表示这段话已经发完了；QUIT表示客户端想要退出。客户端的程序有点让我为难，既要在命令行输入又要同时保证能输出别人发过来的消息，所有我只好用了prompt_toolkit再加上一个线程。如下：

 import socket, prompt_toolkit, select
 import threading, queue

 class Client:
     def __init__(self, sock):
         self.sock = sock
         self.want_to_send = False
         self.want_to_recv = True
         self._msg = queue.Queue()

     def fileno(self):
         return self.sock.fileno()

     def handle_recv(self):
         print('接受消息..')
         msg = self.sock.recv(1024)
         print(str(msg, 'utf-8'))

     def handle_send(self):
         msg = self._msg.get()
         if msg == '\r\n':
             self.want_to_send = False
             self.want_to_recv = False
         self.sock.sendall(bytes(msg, 'utf-8'))
         self.want_to_send = False

 def handle_sock(want_to_send, want_to_recv, sock):
     print('开始处理消息...')
     want_to_recv.append(sock.fileno())
     while True:
         if sock.want_to_send:
             if not want_to_send:
                 want_to_send.append(myclient.fileno())
         else:
             want_to_send.clear()
         can_recv, can_send, _ = select.select(want_to_recv, want_to_send, [], 1)
         if can_recv:
             sock.handle_recv()
         if can_send:
             sock.handle_send()
         if not (sock.want_to_send or sock.want_to_recv):
             print('正停止客户端连接...')
             break
         if sock._msg.qsize():
             sock.want_to_send = True

 s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 s.connect(('127.0.0.1',8001))

 myclient = Client(s)
 want_to_send = []
 want_to_recv = []

 t = threading.Thread(target=handle_sock,
                      args=(want_to_send, want_to_recv, myclient),
                      daemon=True)
 t.start()

 try:
     while True:
         messages = prompt_toolkit.shortcuts.prompt('\n\n>>> ',patch_stdout=True)
         myclient._msg.put(messages+'\n\n')
 except KeyboardInterrupt:
     myclient._msg.put('\r\n')
 finally:
     t.join()
     myclient.sock.close()
     print('网络已断开')

我的服务器跑在 jupyter 上，客户端跑在命令行上，效果如下：

　　客户端接受和发送消息都是互不影响的，这样就实现了一个多人聊天的功能。而且服务器使用的是epoll，所以哪怕是成千上万的人同时在线也没有任何压力。至于怎么测试暂时还没想到办法。