python select

在学习select之前要先了解IO多路复用模型，下面找了三篇文章
https://www.jianshu.com/p/6a6845464770
https://zhuanlan.zhihu.com/p/42044997
https://www.cnblogs.com/yanguhung/p/10145755.html

select
select最早于1983年出现在4.2BSD中，它通过一个select()系统调用来监视多个文件描述符的数组，当select()返回后，该数组中就绪的文件描述符便会被内核修改标志位，使得进程可以获得这些文件描述符从而进行后续的读写操作。
关于文件描述符与socket连接看这篇文章https://www.cnblogs.com/DengGao/p/file_symbol.html
文件描述符https://www.jianshu.com/p/a2df1d402b4d
select目前几乎在所有的平台上支持，其良好跨平台支持也是它的一个优点，事实上从现在看来，这也是它所剩不多的优点之一。

select的一个缺点在于单个进程能够监视的文件描述符的数量存在最大限制，在Linux上一般为1024，不过可以通过修改宏定义甚至重新编译内核的方式提升这一限制。

另外，select()所维护的存储大量文件描述符的数据结构，随着文件描述符数量的增大，其复制的开销也线性增长。同时，由于网络响应时间的延迟使得大量TCP连接处于非活跃状态，但调用select()会对所有socket进行一次线性扫描，所以这也浪费了一定的开销。

poll
poll在1986年诞生于System V Release 3，它和select在本质上没有多大差别，但是poll没有最大文件描述符数量的限制。

poll和select同样存在一个缺点就是，包含大量文件描述符的数组被整体复制于用户态和内核的地址空间之间，而不论这些文件描述符是否就绪，它的开销随着文件描述符数量的增加而线性增大。

另外，select()和poll()将就绪的文件描述符告诉进程后，如果进程没有对其进行IO操作，那么下次调用select()和poll()的时候将再次报告这些文件描述符，所以它们一般不会丢失就绪的消息，这种方式称为水平触发（Level Triggered）。

epoll
直到Linux2.6才出现了由内核直接支持的实现方法，那就是epoll，它几乎具备了之前所说的一切优点，被公认为Linux2.6下性能最好的多路I/O就绪通知方法。

epoll可以同时支持水平触发和边缘触发（Edge Triggered，只告诉进程哪些文件描述符刚刚变为就绪状态，它只说一遍，如果我们没有采取行动，那么它将不会再次告知，这种方式称为边缘触发），理论上边缘触发的性能要更高一些，但是代码实现相当复杂。

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

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

import select
import socket
import sys
import queue
 
# 创建socket server
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.setblocking(False)
server_address = ('localhost', 6666)
server.bind(server_address)
server.listen(5)
 #需要监控的列表
inputs = [ server,]
outputs = [ ]
 
message_queues = {}
while 1:
    readable, writable, exceptional = select.select(inputs, outputs, inputs) #堵塞，监听inputs，只有数据到来才会继续执行
    for r in readable:
        if r is server:
            conn, addr = s.accept()
            conn.setblocking(False)
            #当是server时，就是一个新的连接，把它添加到监控列表中
            inputs.append(conn)
 
            message_queues[conn] = queue.Queue()
        else:
            data = r.recv(1024)
            if data:
                message_queues[s].put(data)
                if r not in outputs:
                    outputs.append(r)
            else:
                if r in outputs:
                    outputs.remove(r)  #客户端都断开时，我就不用再给它返回数据。
                inputs.remove(r)    #inputs也删除掉
                r.close()           #连接关闭

                del message_queues[r]
    # 从outputs取出需要发送数据的对象
    for r in writable:
        try:
            next_msg = message_queues[r].get_nowait()
        except queue.Empty:
            outputs.remove(r)
        else:
            r.send(next_msg)
	#如果出错的话，就从inputs中删除监控对象
    for r in exceptional:
        inputs.remove(s)
        if r in outputs:
            outputs.remove(s)
        r.close()
 
        del message_queues[r]

接下来我们使用 python3 提供的 selectros 来改造它，这个模块封装了操作系统底层提供的 I/O 复用机制，比如 linux 上使用了 epoll。通过 I/O 复用机制我们可以监听多个文件描述符的可读写事件并且注册回调函数，拥有更好的并发性能。 先看 python3 的 selectors 文档给的例子

import selectors
import socket

sel = selectors.DefaultSelector()

def accept(sock, mask):
    conn, addr = sock.accept()  # Should be ready
    print('accepted', conn, 'from', addr)
    conn.setblocking(False)
    sel.register(conn, selectors.EVENT_READ, read)

def read(conn, mask):
    data = conn.recv(1000)  # Should be ready
    if data:
        print('echoing', repr(data), 'to', conn)
        conn.send(data)  # Hope it won't block
    else:
        print('closing', conn)
        sel.unregister(conn)
        conn.close()

sock = socket.socket()
sock.bind(('localhost', 1234))
sock.listen(100)
sock.setblocking(False)
sel.register(sock, selectors.EVENT_READ, accept)

while True:  # 这其实就是通常在异步框架中所说的 event loop 啦
    events = sel.select()
    for key, mask in events:
        callback = key.data
        callback(key.fileobj, mask)