多路复用

参考
http://www.cnblogs.com/Eva-J/articles/8324837.html

IO多路复用

IO模型介绍

同步、异步、阻塞、非阻塞
限定环境Linux环境下的network IO。参考文献是Richard Stevens的“UNIX® Network Programming Volume 1, Third Edition: The Sockets Networking ”，6.2节“I/O Models ”。
Stevens在文章中一共比较了五种IO Model：

• blocking IO 阻塞IO
• nonblocking IO 非阻塞IO
• IO multiplexing IO多路复用
• signal driven IO 信号驱动IO
• asynchronous IO 异步IO

由signal driven IO（信号驱动IO）在实际中并不常用，所以主要介绍其余四种IO Model。
IO发生时涉及的对象和步骤。对于一个network IO (这里我们以read举例)，它会涉及到两个系统对象，一个是调用这个IO的process (or thread)，另一个就是系统内核(kernel)。当一个read操作发生时，该操作会经历两个阶段：

1. 等待数据准备 (Waiting for the data to be ready)
2. 将数据从内核拷贝到进程中(Copying the data from the kernel to the process)

阻塞IO(blocking IO)

在linux中，默认情况下所有的socket都是blocking。

wait,copy都是阻塞的。等待数据，数据来了，把数据从内核copy到进程。
所以，blocking IO的特点就是在IO执行的两个阶段（等待数据和拷贝数据两个阶段）都被block了。

非阻塞IO(non-blocking IO)

Linux下，可以通过设置socket使其变为non-blocking。

wait,轮询检查内核数据有没有准备好，可以执行其他操作，在这一步IO不是阻塞的。
copy,数据到了，copy到进程。copy过程是阻塞的。
所以，在非阻塞式IO中，用户进程其实是需要不断的主动询问kernel数据准备好了没有。
虽然但是非阻塞IO模型在等待数据部分不是阻塞的，但是绝不被推荐
优点
能够在IO的时间里把其他任务做了(后台有多个任务可以"同时"执行)。
缺点

1. 循环主动轮询将将大幅度推高CPU占用率。
2. 任务完成的响应延迟增大了，因为每过一段时间才去主动轮询一次，而任务可能在两次轮询之间的任意时间完成。这会导致整体数据吞吐量的降低。

非阻塞IO示例

# 服务端
import socket

server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.bind(('127.0.0.1', 8866))
server.listen(10)
server.setblocking(False)  # 设置socket的接口为非阻塞
del_list = []
conn_list = []
while True:
    try:
        conn, addr = server.accept()
        conn_list.append(conn)
    except BlockingIOError as e:

        for conn in conn_list:
            try:
                res = conn.recv(1024)
                if not res:
                    del_list.append(conn_list)
                    continue
                conn.send(res.decode('utf-8').upper().encode('utf-8'))

            except BlockingIOError:
                pass
            except ConnectionResetError:
                del_list.append(conn)

        for conn in del_list:
            conn_list.remove(conn)
            conn.close()
        del_list = []
        
        
# 客户端
import socket

client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client.connect(('127.0.0.1', 8866))

while True:
    msg = input('>>>')
    if not msg:
        continue
    client.send(msg.encode('utf-8'))
    res = client.recv(1024)
    print(res.decode('utf-8'))

多路复用IO(IO multiplexing)

wait操作不阻塞，copy操作阻塞。
IO multiplexing这个词可能有点陌生，但是如果我说select/epoll，大概就都能明白了。有些地方也称这种IO方式为事件驱动IO(event driven IO)。我们都知道，select/epoll的好处就在于单个process就可以同时处理多个网络连接的IO。它的基本原理就是select/epoll这个function会不断的轮询所负责的所有socket，当某个socket有数据到达了，就通知用户进程。
当用户进程调用了select，那么整个进程会被block，而同时，kernel会“监视”所有select负责的socket，当任何一个socket中的数据准备好了，select就会返回。这个时候用户进程再调用read操作，将数据从kernel拷贝到用户进程。
这个图和blocking IO的图其实并没有太大的不同，事实上还更差一些。因为这里需要使用两个系统调用(select和recvfrom)，而blocking IO只调用了一个系统调用(recvfrom)。但是，用select的优势在于它可以同时处理多个connection。
强调：

1. 如果处理的连接数不是很高的话，使用select/epoll的web server不一定比使用multi-threading + blocking IO的web server性能更好，可能延迟还更大。select/epoll的优势并不是对于单个连接能处理得更快，而是在于能处理更多的连接。
2. 在多路复用模型中，对于每一个socket，一般都设置成为non-blocking，但是，如上图所示，整个用户的process其实是一直被block的。只不过process是被select这个函数block，而不是被socket IO给block。

结论: select的优势在于可以处理多个连接，不适用于单个连接

改模型优点：
相比其他模型，使用select() 的事件驱动模型只用单线程（进程）执行，占用资源少，不消耗太多 CPU，同时能够为多客户端提供服务。如果试图建立一个简单的事件驱动的服务器程序，这个模型有一定的参考价值。
该模型的缺点：
首先select()接口并不是实现“事件驱动”的最好选择。因为当需要探测的句柄值较大时，select()接口本身需要消耗大量时间去轮询各个句柄。
很多操作系统提供了更为高效的接口，如linux提供了epoll，BSD提供了kqueue，Solaris提供了/dev/poll，…。
如果需要实现更高效的服务器程序，类似epoll这样的接口更被推荐。遗憾的是不同的操作系统特供的epoll接口有很大差异，
所以使用类似于epoll的接口实现具有较好跨平台能力的服务器会比较困难。
其次，该模型将事件探测和事件响应夹杂在一起，一旦事件响应的执行体庞大，则对整个模型是灾难性的

select网络IO模型

# 服务端
import socket
import select

server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.bind(('127.0.0.1', 8844))
server.listen(10)
server.setblocking(False)  # 设置socket接口不阻塞
server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) 
read_l = [server, ]
while True:
    r_l, w_l, x_l = select.select(read_l, [], [])
    print(r_l)
    for ready_obj in r_l:
        if ready_obj == server:
            conn, addr = ready_obj.accept()  # 此时的ready_obj等于server
            read_l.append(conn)
        else:
            try:
                res = ready_obj.recv(1024)  # # 此时的ready_obj等于conn
                if not res:
                    ready_obj.close()
                    r_l.remove(ready_obj)
                    continue
                ready_obj.send(res.upper())
            except ConnectionResetError:
                ready_obj.close()
                r_l.remove(ready_obj)


# 客户端
import socket

client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client.connect(('127.0.0.1', 8844))

while True:
    msg = input('>>>')
    if not msg:
        continue
    client.send(msg.encode('utf-8'))
    res = client.recv(1024)
    print(res.decode('utf-8'))

异步IO

wait,copy操作都不阻塞。
Linux下的asynchronous IO其实用得不多，从内核2.6版本才开始引入。

用户进程发起read操作之后，立刻就可以开始去做其它的事。而另一方面，从kernel的角度，当它受到一个asynchronous read之后，首先它会立刻返回，所以不会对用户进程产生任何block。然后，kernel会等待数据准备完成，然后将数据拷贝到用户内存，当这一切都完成之后，kernel会给用户进程发送一个signal，告诉它read操作完成了。

IO模型比较

blocking和non-blocking的区别
调用blocking IO会一直block住对应的进程直到操作完成，而non-blocking IO在kernel还准备数据的情况下会立刻返回。

synchronous IO和asynchronous IO的区别
两者的定义，Stevens给出的定义（其实是POSIX的定义）是这样子的：
A synchronous I/O operation causes the requesting process to be blocked until that I/O operationcompletes;
An asynchronous I/O operation does not cause the requesting process to be blocked;
两者的区别就在于synchronous IO做”IO operation”的时候会将process阻塞。按照这个定义，四个IO模型可以分为两大类，之前所述的blocking IO，non-blocking IO，IO multiplexing都属于synchronous IO这一类，而 asynchronous I/O后一类 。

经过上面的介绍，会发现non-blocking IO和asynchronous IO的区别还是很明显的。在non-blocking IO中，虽然进程大部分时间都不会被block，但是它仍然要求进程去主动的check，并且当数据准备完成以后，也需要进程主动的再次调用recvfrom来将数据拷贝到用户内存。而asynchronous IO则完全不同。它就像是用户进程将整个IO操作交给了他人（kernel）完成，然后他人做完后发信号通知。在此期间，用户进程不需要去检查IO操作的状态，也不需要主动的去拷贝数据。

selectors模块

select,poll,epoll
这三种IO多路复用模型在不同的平台有着不同的支持，而epoll在windows下就不支持，好在我们有selectors模块，帮我们默认选择当前平台下最合适的