Kqueue 实现非阻塞 Socket 通信 - HelloWorld开发者社区

如果有误，请大神指出啊！

之前留下的坑

之前写过一篇 kqueue 实现文件操作监控，讲了 Kqueue 在文件监控的应用，文章给出的例子只对于一个 test 文件进行监控。

Kqueue 或者 Epoll 更多的是被使用在 Socket 通信的场景中，于是我又写了一个带有 Socket 的版本。代码如下：

# coding=utf-8
import select
from socket import socket
from socket import AF_INET, SOCK_STREAM, SOL_SOCKET, SO_REUSEADDR
from threading import Thread

fd = open('test')
s = socket(AF_INET, SOCK_STREAM)
s.bind(("127.0.0.1", 3000))
s.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
s.listen(1)
kq = select.kqueue()
flags = select.KQ_EV_ADD | select.KQ_EV_ENABLE | select.KQ_EV_CLEAR
fflags = select.KQ_NOTE_DELETE | select.KQ_NOTE_WRITE | select.KQ_NOTE_EXTEND \
         | select.KQ_NOTE_RENAME

# 监测文件事件，如果有新事件在这个 fd 上发生，则返回，监测事件类型由 fflags 规定
file_ev = select.kevent(fd.fileno(), filter=select.KQ_FILTER_VNODE, flags=flags, fflags=fflags)

# 监测 Socket 事件，如果有新数据可读则返回
socket_ev = select.kevent(s.fileno(), filter=select.KQ_FILTER_READ, flags=flags)

# 监测多个对象就只需把很多 kevent 对象塞进 events 列表中，然后传递给 control 函数
events = []
events.append(file_ev)
events.append(socket_ev)


# 处理这个 socket 请求
def socket_handler(cl):
    while True:
        data = cl.recv(100)
        print data
        if not data:
            cl.close()
            print 'socket closed'
            break

while True:
    revents = kq.control(events, 1, None)
    for e in revents:
        # 如果是 socket 触发的事件
        if e.ident == s.fileno():
            print 'Event from socket'
            if e.filter & select.KQ_FILTER_READ:
                cl, _ = s.accept()
                # 如果直接调用 socket_handler 函数，那么这个 eventloop 会被阻塞，所以此处使用线程
                Thread(None, socket_handler, args=(cl,)).start()
            else:
                print e
        # 如果是文件触发的事件
        if e.ident == fd.fileno():
            print 'Event from file'
            if e.fflags & select.KQ_NOTE_EXTEND:
                print 'extend'
            elif e.fflags & select.KQ_NOTE_WRITE:
                print 'write'
            elif e.fflags & select.KQ_NOTE_RENAME:
                print 'rename'
            elif e.fflags & select.KQ_NOTE_DELETE:
                print 'delete'
            else:
                print e

然而随时时间的推移，我发现其实这是有大大的问题的，我自作聪明地为每个新链接产生一个线程应付 Client，然而如果当 Client 源源不断地涌入时，线程数会超标，导致程序发送错误。就算我们维护一个线程的列表，使列表的长度不大于某个标准，每次创建线程的损耗也是存在的。

性能对比

首先我们建立了一个 KqueueEventLoop 的循环类，代码如下：

# 部分代码参考了 SS 源码中的实现
class KqueueEventLoop(object):

    KQ_FILTER_READ = select.KQ_FILTER_READ

    def __init__(self):
        self._fd_map = {}
        self._handler_map = {}
        self._event_map = {}
        self.kq = select.kqueue()
        self.klist = []
        self._stop = False

    # 启动这个事件循环
    def run(self):
        while not self._stop:
            events = self.poll()
            for e in events:
                self._fd_map[e.ident](self._handler_map[e.ident])

    # 从事件池里面取事件出来
    def poll(self):
        events = self.kq.control(self.klist, 1, None)
        return events

    # 注册事件
    def add(self, f, mode, handler):
        fd = f.fileno()
        event = select.kevent(fd, filter=mode, flags=select.KQ_EV_ADD | select.KQ_EV_ENABLE | select.KQ_EV_CLEAR)
        self._handler_map[fd] = f
        self._fd_map[fd] = handler
        self._event_map[fd] = event
        self.klist.append(event)

    # 删除事件
    def remove(self, f):
        fd = f.fileno()
        del self._handler_map[fd]
        del self._fd_map[fd]
        self.klist.remove(self._event_map[fd])

    # 暂停事件循环
    def stop(self):
        self._stop = True

如果是用一开始的代码的想法，为每个 Client 生成一个线程，调用方法如下：

def test():
    loop = KqueueEventLoop()
    s = socket(AF_INET, SOCK_STREAM)
    s.bind(("127.0.0.1", 3000))
    s.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
    s.listen(5)

    def callback(f):
        Thread(None, handler, args=(f,)).start()

    def handler(f):
        print 'INFO: New connection established.'
        cl, _ = f.accept()
        while True:
            data = cl.recv(1024)
            if not data:
                print 'INFO: Connection dropped.'
                loop.remove(cl)
                cl.close()
                return
            print 'DATA: %s' % repr(data)

    loop.add(s, KqueueEventLoop.KQ_FILTER_READ, callback)
    loop.run()

if __name__ == '__main__':
    test()

我们模拟了一个 100 个客户端，每隔 0.1 秒向服务器发 1，获取到该服务端内存使用量为 14MB。之前提到这边线程的产生会造成两个严重的问题，所以我们就不生成线程。那么怎么做到原来的 while 循环来接受这么多客户端发来的数据呢？答案是，不用 while 循环。

继续注册事件

当事件池返回一个新连接建立请求时，接受并建立这个连接，再把这个连接扔回事件池中，代码如下：

def test():
    loop = KqueueEventLoop()
    s = socket(AF_INET, SOCK_STREAM)
    s.bind(("127.0.0.1", 3000))
    s.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
    s.listen(5)

    def handler(f):
        print 'INFO: New connection established.'
        cl, _ = f.accept()
        cl.setblocking(False)
        loop.add(cl, KqueueEventLoop.KQ_FILTER_READ, read_data)

    def read_data(cl):
        try:
            data = cl.recv(1024)
            if not data:
                print 'INFO: Connection dropped.'
                loop.remove(cl)
                cl.close()
                return
            print 'DATA: %s' % repr(data)
        except Exception, e:
            print 'ERROR: %s' % repr(e)
            loop.remove(cl)
            cl.close()

    loop.add(s, KqueueEventLoop.KQ_FILTER_READ, handler)
    loop.run()

if __name__ == '__main__':
    test()

我们通过 loop.add(cl, KqueueEventLoop.KQ_FILTER_READ, read_data) 将每个新连接 cl 加入到事件循环 loop 中，并让事件循环类记录回调方法 read_data。此时的状况就是，整个程序只有一个事件循环，每来一个新连接，通过 handler 回调建立该连接。再如果网卡接受到新数据，KqueueEventLoop 找到新数据对应的连接，把数据读入内存并打印出来。

以上实现没有了新建线程带来的损耗，整个程序只保留了一个 while 循环，使得相同情况下内存使用量仅为 5MB。并且并发连接数量有很大提升，不再受限于线程数限制。