利用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，所以哪怕是成千上万的人同时在线也没有任何压力。至于怎么测试暂时还没想到办法。