day10-IO多路复用

一、IO多路复用

IO多路复用中包括 select、pool、epoll，这些都属于同步而非异步

a.select：

通过一个select()系统调用来监视多个文件描述符的数组，当select()返回后，该数组中就绪的文件描述符便会被内核修改标志位，使得进程可以获得这些文件描述符从而进行后续的读写操作，几乎在所有平台支持，但是单个进程能够监视的文件描述符的数量存在最大限制，在Linux上一般为1024，不过可以通过修改宏定义甚至重新编译内核的方式提升这一限制。

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

b.poll：

和select在本质上没有多大差别，但是poll没有最大文件描述符数量的限制。

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

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

c.epoll 

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

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

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

二、select代码实现

Python的select()方法直接调用操作系统的IO接口，它监控sockets,open files, and pipes(所有带fileno()方法的文件句柄)何时变成readable 和writeable, 或者通信错误

select()使得同时监控多个连接变的简单，并且这比写一个长循环来等待和监控多客户端连接要高效，

因为select直接通过操作系统提供的C的网络接口进行操作，而不是通过Python的解释器，仅支持Unix系统

import select
import socket
import Queue

server = socket.socket()
server.bind(('localhost', 9000))
server.listen(5)

# 设置不阻塞
server.setblocking(False)

msg_dic = {}

# inputs放入需要检测的链接，一开始只有自己的连接，故放入列表
inputs = [server, ]
outputs = []

while True:
    # exceptional表示如果inputs列表中出现异常，会输出到这个exceptional中
    readable, writeable, exceptional = select.select(inputs, outputs, inputs)
    print readable, writeable, exceptional

    for r in readable:
        # 代表新连接
        if r is server:
            print("new connection")
            conn, addr = server.accept()
            print conn, addr
            inputs.append(conn)
            # 初始化一个队列，后面存要返回给这个客户端的数据
            msg_dic[conn] = Queue.Queue()
        # 代表连接实例
        else:
            data = r.recv(1024)
            if data:
                print("received: ", data)
                msg_dic[r].put(data)
                # 放入返回的连接队列里
                outputs.append(r)
                # r.send(data)
                # print("send done")
            # 收不到数据代表连接断开
            else:
                print("conection close")
                if r in outputs:
                    outputs.remove(r)
                inputs.remove(r)
                del msg_dic[r]


    # 要返回给客户端的连接列表
    for w in writeable:
        data_to_client = msg_dic[w].get()
        # 返回给客户端源数据
        w.send(data_to_client)
        # 确保下次循环的时候writeable不返回已经处理完的连接
        outputs.remove(w)

    # 异常连接列表
    for e in exceptional:
        if e in outputs:
            outputs.remove(e)
        inputs.remove(e)
        del msg_dic[e]

三、alex完整代码

server端：

#_*_coding:utf-8_*_
__author__ = 'Alex Li'

import select
import socket
import sys
import queue


server = socket.socket()
server.setblocking(0)

server_addr = ('localhost',10000)

print('starting up on %s port %s' % server_addr)
server.bind(server_addr)

server.listen(5)


inputs = [server, ] #自己也要监测呀,因为server本身也是个fd
outputs = []

message_queues = {}

while True:
    print("waiting for next event...")

    readable, writeable, exeptional = select.select(inputs,outputs,inputs) #如果没有任何fd就绪,那程序就会一直阻塞在这里

    for s in readable: #每个s就是一个socket

        if s is server: #别忘记,上面我们server自己也当做一个fd放在了inputs列表里,传给了select,如果这个s是server,代表server这个fd就绪了,
            #就是有活动了, 什么情况下它才有活动? 当然 是有新连接进来的时候 呀
            #新连接进来了,接受这个连接
            conn, client_addr = s.accept()
            print("new connection from",client_addr)
            conn.setblocking(0)
            inputs.append(conn) #为了不阻塞整个程序,我们不会立刻在这里开始接收客户端发来的数据, 把它放到inputs里, 下一次loop时,这个新连接
            #就会被交给select去监听,如果这个连接的客户端发来了数据 ,那这个连接的fd在server端就会变成就续的,select就会把这个连接返回,返回到
            #readable 列表里,然后你就可以loop readable列表,取出这个连接,开始接收数据了, 下面就是这么干 的

            message_queues[conn] = queue.Queue() #接收到客户端的数据后,不立刻返回 ,暂存在队列里,以后发送

        else: #s不是server的话,那就只能是一个 与客户端建立的连接的fd了
            #客户端的数据过来了,在这接收
            data = s.recv(1024)
            if data:
                print("收到来自[%s]的数据:" % s.getpeername()[0], data)
                message_queues[s].put(data) #收到的数据先放到queue里,一会返回给客户端
                if s not  in outputs:
                    outputs.append(s) #为了不影响处理与其它客户端的连接 , 这里不立刻返回数据给客户端


            else:#如果收不到data代表什么呢? 代表客户端断开了呀
                print("客户端断开了",s)

                if s in outputs:
                    outputs.remove(s) #清理已断开的连接

                inputs.remove(s) #清理已断开的连接

                del message_queues[s] ##清理已断开的连接


    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]

select socket server

client端：

#_*_coding:utf-8_*_
__author__ = 'Alex Li'


import socket
import sys

messages = [ b'This is the message. ',
             b'It will be sent ',
             b'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 listening
print('connecting to %s port %s' % server_address)
for s in socks:
    s.connect(server_address)

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() )

select socket client

四、selectors

# selectors默认方式为epoll,如果找不到epoll(如windows),会去找select

import selectors
import socket

# 定义selectors对象
sel = selectors.DefaultSelector()


def accept(sock, mask):
    """接收客户端信息实例"""
    conn, addr = sock.accept()
    print("accepted", conn, 'from', addr)
    # 设置非阻塞
    conn.setblocking(False)
    # 注册事件，有新连接回调read函数
    sel.register(conn, selectors.EVENT_READ, read)


def read(conn,mask):
    """接收客户端的数据"""
    data = conn.recv(1024)
    if data:
        print("echoing", repr(data), 'to',c onn)
        conn.send(data)
    else:
        print("closing", conn)
        sel.unregister(conn)
        conn.close()

server = socket.socket()
server.bind(('localhost',9999))
server.listen(500)
server.setblocking(False)
# 注册事件，有新连接实例回调accept函数，这里相当于inputs=[server,]
sel.register(server,selectors.EVENT_READ,accept)

while True:
    # 阻塞selectors对象,有活动连接时返回活动连接列表
    events = sel.select()
    print("事件：",events)
    # 循环事件
    for key, mask in events:
        # 相当于回调函数，第一次调用的是accept,第二次调用的是read
        callback = key.data
        # key.fileobj=文件句柄
        callback(key.fileobj,mask)

客户端高可用代码：

import socket,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(100)]
 
# 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)
 
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() )