第十一章：网络通信-select:高效等待I/O-使用select()

11.4 select:高效等待I/O
select模块允许访问特定于平台的I/O监视函数。最可移植的接口是POSIX函数select()，UNIX和Windows都提供了这个函数。这个模块还包括函数poll()(这个API只适合用于UNIX)，另外还提供了很多只适用于一些UNIX特定版本的选项。
说明：新的selectors模块提供了建立在select API之上的一个更高层的接口。使用selectors可以更容易地构建可移植的代码，所以除非处于某种原因必须使用select提供的底层API，否则最好使用selectors模块。

11.4.1 使用select()
Python的select()函数是底层操作系统实现的一个直接接口。它会监视套接字、打开的文件和管道(可以是任何有fileno()方法的对象，这个方法返回一个合法的文件描述符)，直到这个对象可读或可写，或者出现一个通信错误。利用select()可以很容易地同时监视多个连接，这比在Python中使用套接字超时编写一个轮询循环更为高效，因为监视发生在操作系统网络层而不是在解释器中完成。
说明：对Python文件对象使用select()只适用于UNIX，在windows下并不支持。
可以扩展socket一节的回送服务器例子，通过使用select()同时监视多个连接。这个新版本首先创建一个非阻塞的TCP/IP套接字，将它配置为监听一个地址。

import select
import socket
import sys
import queue

# Create a TCP/IP socket.
server = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
server.setblocking(0)

# Bind the socket to the port.
server_address = ('localhost',10000)
print('starting up on {} port {}'.format(*server_address),
      file=sys.stderr)
server.bind(server_address)

# Listen for incoming connections.
server.listen(5)

# select()的参数是3个列表，包含要监视的通信通道。首先检查第一个对象列表中的对象
# 以得到要读取的数据。第二个列表中包含的对象将接收发出的数据(如果缓冲区有空间),
# 第三个列表包含哪些可能有错误的对象(通常是输入和输出通道对象的组合)。下一步是
# 建立这些列表，其中包含要传至select()的输入源和输出目标。

# Sockets from which we expect to read
inputs = [server]

# Sockets to which we expect to write
outputs = []

# 由服务器主循环向这些列表增加或删除连接。由于这个服务器版本在发送数据之前要等待
# 套接字变为可写(而不是立即发送应答)，所以每个输出连接都需要一个队列作为通过这个
# 套接字发送的数据的缓冲区。

# Outgoing message queues (socket:Queue)
message_queues = {}

# 服务器程序的主要部分会循环调用select()来阻塞并等待网络活动。
while inputs:

    # Wait for at least one of the sockets to be
    # ready for processing.
    print('waiting for the next event',file=sys.stderr)
    readable,writable,exceptional = select.select(inputs,outputs,inputs)

    # select()返回3个新列表，包含所传入列表内容的子集。readable雷彪中的所有套接字
    # 会缓存到来的数据，可供读取。writable列表中所有套接字的缓冲区中有自由空间，
    # 可以写入数据。exceptional中返回的套接字都有一个错误("异常条件"的具体定义取决
    # 于平台)。
    # “可读”套接字表示3种可能的情况。如果套接字是主“服务器”套接字，即用来监听
    # 连接的套接字，那么“可读”条件就意味着它已经准备就绪，可以接受另一个入站连接
    # 除了将新连接增加到要监视的输入列表，这里还会将客户套接字设置为非阻塞。

    # Handle inputs
    for s in readable:
        if s is server:
            # A "readable" socket is ready to accept a connection.
            connection,client_address = s.accept()
            print('  connection from',client_address,
                    file=sys.stderr)
            connection.setblocking(0)
            inputs.append(connection)

            # Give the connection a queue for data
            # we want to send.
            message_queues[connection] = queue.Queue()

    # 下一种情况是与一个已发送数据的客户建立连接。数据用recv()读取，然后放置在
    # 队列中，以便通过套接字发送并返回给客户。

        else:
            data = s.recv(1024)
            if data:
                # A readable client socket has data.
                print('  received {!r} from {}'.format(
                    data,s.getpeername()),file=sys.stderr,
                          )
                message_queues[s].put(data)
                # Add output channel for response.
                if s not in outputs:
                    outputs.append(s)

    # 如果一个可读套接字未从recv()返回数据，那么说明这个套接字来自已经断开连接
    # 的客户，此时可以关闭流。

            else:
                # Interpret empty result as closed connection.
                print('  closing',client_address,
                        file=sys.stderr)
                # Stop listening for input on the connection.
                if s in outputs:
                    outputs.remove(s)
                inputs.remove(s)
                s.close()

                # Remove message queue.
                del message_queues[s]

    # 对于可写连接，情况要少一些。如果一个连接的相应队列中有数据，那么就发送下
    # 一个消息。否则，将这个连接从输出连接列表中删除，这样下一次循环时，select()
    # 不再指示这个套接字已准备好发送数据。

    # Handle outputs.
    for s in writable:
        try:
            next_msg = message_queues[s].get_nowait()
        except queue.Empty:
            # No messages waiting, so stop checking
            # for writability.
            print('  ',s.getpeername(),'queue empty',
                    file=sys.stderr)
            outputs.remove(s)
        else:
            print('  sending {!r} to {}'.format(next_msg,s.getpeername()),
                    file=sys.stderr)
            s.send(next_msg)

    # 最后一种情况，exceptional列表中的套接字会关闭。

    # Handle "exceptional conditions."
    for s in exceptional:
        print('exception condition on',s.getpeername(),
                file=sys.stderr)
        # Stop listening for input on the connection.
        inputs.remove(s)
        if s in outputs:
            outputs.remove(s)
        s.close()

        # Remove message queue.
        del message_queues[s]

这个示例客户程序使用了两个套接字来展示服务器如何利用select()同时管理多个连接。客户首先将各个TCP/IP套接字连接到服务器。

import socket
import sys

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

# Create a TCP/IP socket.
socks = [
    socket.socket(socket.AF_INET,socket.SOCK_STREAM),
    socket.socket(socket.AF_INET,socket.SOCK_STREAM),
    ]
# Connect the socket to the port where the server is listenting.
print('connecting to {} port {}'.format(*server_address),
      file=sys.stderr)
for s in socks:
    s.connect(server_address)

# 然后通过各个套接字一次发送消息，写新数据之后再读取得到的所有响应。
for message in messages:
    outgoing_data = message.encode()
    # send messages on both sockets.
    for s in socks:
        print('{}: sending {!r}'.format(s.getsockname(),
                                        outgoing_data),
              file=sys.stderr)
        s.send(outgoing_data)

    # Read responses on both sockets.
    for s in socks:
        data = s.recv(1024)
        print('{}: received {!r}'.format(s.getsockname(),
                                         data),
              file=sys.stderr)
        if not data:
            print('closing socket',s.getsockname(),
                  file=sys.stderr)
            s.close()

在一个窗口运行服务器，在另一个窗口运行客户程序。输出如下所示：

客户程序的输出显示了使用这两个套接字发送和接收到的数据。