python之select与selector

select/poll/epoll的区别

I/O多路复用的本质就是用select/poll/epoll，去监听多个socket对象。

参考：Linux IO模式及 select、poll、epoll详解

1. select是不断轮询去监听的socket，socket个数有限制，一般为1024个（文件描述符为1024，该值可以修改）；随着文件描述符数量增加，轮询一回成本增加。
2. poll采用轮询方式监听，只不过没有个数限制；
3. epoll不采用轮询方式去监听，而是当socket有变化时通过回调的方式主动告知用户进程；无最大链接数的限制。

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

边缘触发（Edge Triggered），只告诉进程哪些文件描述符刚刚变为就绪状态，它只说一遍，如果我们没有采取行动，那么它将不会再次告知，这种方式称为边缘触发。

select

参考：https://docs.python.org/3/library/select.html#module-select

参考：https://pymotw.com/2/select/#module-select

Python的select()方法直接调用操作系统的IO接口，它监控sockets,open files, and pipes(所有带fileno()方法的文件句柄)何时变成readable 和writeable, 或者通信错误，select()使得同时监控多个连接变的简单，并且这比写一个长循环来等待和监控多客户端连接要高效，因为select直接通过操作系统提供的C的网络接口进行操作，而不是通过Python的解释器。

select使用

1. 创建两个列表来表示输入输出信息给select： select()方法接收并监控3个通信列表， 第一个是所有的输入的data，就是指外部发过来的数据，第2个是监控和接收所有要发出去的data，第3个监控错误信息；
2. select()返回3个新的list，分别赋值为readable，writable，exceptional。所有在readable list中的socket连接代表有数据可接收(recv)；所有在writable list中的存放着你可以对其进行发送(send)操作的socket连接；当连接通信出现error时会把error写到exceptional列表中。

Readable list 中的socket 3种可能状态

• 第一种是如果这个socket是main "server" socket,它负责监听客户端的连接，如果这个main server socket出现在readable里，那代表这是server端已经ready来接收一个新的连接进来了，为了让这个main server能同时处理多个连接，在下面的代码里，我们把这个main server的socket设置为非阻塞模式。
• socket是已经建立了的连接，它把数据发了过来，这个时候你就可以通过recv()来接收它发过来的数据，然后把接收到的数据放到queue里，这样你就可以把接收到的数据再传回给客户端了。
• 这个客户端已经断开了，所以你再通过recv()接收到的数据就为空了，所以这个时候你就可以把这个跟客户端的连接关闭了。

writable list中的socket

• 如果这个客户端连接在跟它对应的queue里有数据，就把这个数据取出来再发回给这个客户端；
• 否则就把这个连接从output list中移除，这样下一次循环select()调用时检测到outputs list中没有这个连接，那就会认为这个连接还处于非活动状态。

server

import socket
import select
import queue


HOST = ('localhost',9999)
server = socket.socket()
server.setblocking(False)
server.bind(HOST)
server.listen(3)

inputs = [server,]
outputs = []
message_queues = {}
print('inputs:',inputs)

while True:
    print('waiting for next event')
    print('***************inputs:', inputs)
    readable, writeable, exeptional = select.select(inputs,outputs,inputs)
    # 如果没有任何fd就绪，程序一直会阻塞在这
    print('-------------readable:',readable )
    for s in readable:
        if s is server:
            conn,addr = s.accept()
            print('server is %',s)
            print('new connection from %s' % conn)
            conn.setblocking(0)
            inputs.append(conn)
            message_queues[conn] = queue.Queue()
        else:
            data = s.recv(1024)
            if data:
                print('收到来自[%s]的数据：%s' %(s.getpeername()[0],data))
                message_queues[s].put(data)
                if s not in outputs:
                    outputs.append(s)
            else:
                print('客户端断开')

                if s in outputs:
                    outputs.remove(s)
                inputs.remove(s)
                del message_queues[s]
    print('++++++++++++=writeabld:',writeable)
    for s in writeable:
        try:
            next_msg = message_queues[s].get_nowait()

        except queue.Empty:
            print("client [%s]" % s.getpeername()[0], "queue is empty..")
            outputs.remove(s)

        else:
            print("sending msg to [%s]" % s.getpeername()[0], next_msg)
            s.send(next_msg.upper())

    for s in exeptional:
        print("handling exception for ", s.getpeername())
        inputs.remove(s)
        if s in outputs:
            outputs.remove(s)
        s.close()

        del message_queues[s]

client

import socket
import sys

messages = [ b'This is the message. ',
             b'It will be sent ',
             b'in parts.',
             ]
server_address = ('localhost', 9999)

# Create a TCP/IP socket
socks = [ socket.socket(socket.AF_INET, socket.SOCK_STREAM) for i in range(3)]

# Connect the socket to the port where the server is listening
print('connecting to %s port %s' % server_address)
for s in socks:
    s.connect(server_address)

print('***',socks)
for message in messages:

    # Send messages on both sockets
    for s in socks:
        print('%s: sending "%s"' % (s.getsockname(), message) )
        s.send(message)

    # Read responses on both sockets
    for s in socks:
        data = s.recv(1024)
        print( '%s: received "%s"' % (s.getsockname(), data) )
        if not data:
            print(sys.stderr, 'closing socket', s.getsockname() )
 

selector

参考：https://docs.python.org/3/library/selectors.html

　　这个模块允许高级别和高效的I/O多路复用，建立在select模块之上，相当于epoll。如果不是对精确OS级别的原语控制，推荐使用这个模块。

　　selector定义了一个BaseSelector抽象基类，以及一些具体的实现(KqueueSelector, EpollSelector…)，可以用于在多个文件对象上等待I/O准备通知。

　　DefaultSelector是当前平台上可用的最高效实现的别名：这应该是大多数用户的默认选择。

　　支持的文件对象类型取决于平台：在Windows上，支持套接字，但不支持管道，而在Unix上，两者都得到支持(一些其他类型也可以支持，比如fifos或特殊文件设备)。

　　事件：一个位掩码，指示在给定的文件对象上应该等待哪些I/O事件。它可以是以下模块常用的组合

EVENT_READ：  Available for read
EVENT_WRITE：Available for write

　　class selectors.DefaultSelector                  默认选择器类，使用当前平台上可用的最有效的实现。

实例

import selectors
import socket

sel = selectors.DefaultSelector()

def accept(sock, mask):              # sock相当于key.fileobj
    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:
    events = sel.select()     # 根据系统是否支持，使用epoll还是select，优先epoll。默认阻塞，有活动连接就返回活动的连接列表
    for key, mask in events:
        callback = key.data    # 相当于回调accept
        callback(key.fileobj, mask)  # key.fileobj相当于建立连接后的conn

---