IO模型

阻塞IO

除非特别指定，几乎所有的IO接口（包括socket接口）都是阻塞型的。这给网络编程带来了一个很大的问题，如在调用recv(1024)的同时，线程交被阻塞，在此期间，线程将无法执行任何运算或响应任何的网络请求。

简单的解决方案：

在服务器端使用多线程（或多进程）。多线程（或多进程）的目的是让每个连接都拥有独立的线程（或进程），这样任何一个连接的阻塞都不会影响其他的连接。

该方案的问题是：

开启多进程或多线程的方式，在遇到同时响应成百上千路的连接请求，则无论多线程还是多进程都会严重占据系统资源，降低系统对外界响应效率，而且线程与进程本身也更容易进入假死状态。

改进方案：

很多程序员可能会考虑使用线程池或连接池。线程池旨在减少创建和销毁线程的频率，其维持一定合理数量的线程，并让空闲的线程重新承担新的执行任务。连接池维持连接的缓存池，尽量重用已有的连接、减少创建和关闭连接的频率。这两种技术都可以很好的降低系系统开销，都被广泛应用很多大型系统，如websphere、tomcat和各种数据库等。

改进后方案也存在问题：

线程池和连接池技术也只是在一定程度上缓解了频繁调用IO接口带来的资源占用。而且所谓池始终有其上限，当请求大大超过上限时，池构成的系统对外界的响应并不比没有池的时候效果好多少。所以使用池必须考虑其面临的响应规模，并根据响应规模调整池的大小。

对应上例中的所面临的可能同时出现的上千甚至上万次的客户端请求，线程池或连接池或许可以缓解部分压力，但是不对解决所有问题。总之多线程模型可以方便高效的解决小规模的服务请求，但面对大规模的服务请求，多线程模型也会遇到瓶颈，可以用非阻塞接口来尝试解决这个问题。

非阻塞IO

非阻塞式IO中，用户进程其实是需要不断的主动询问kernel数据准备好了没有。

import socket
sk = socket.socket()
sk.bind(('127.0.0.1',8080))
sk.listen()
sk.setblocking(False)
conn_lst = []

while True:
    try:
        conn,addr = sk.accept()
        conn_lst.append(conn)
    except BlockingIOError:
        del_lst = []
        for c in conn_lst:
            try:
                msg = c.recv(1024).decode('utf-8')
                if not msg:
                    c.close()
                    del_lst.append(c)
                else:
                    print(msg)
                    c.send(msg.upper().encode('utf-8'))
            except BlockingIOError:
                pass
        if del_lst:
            for del_item in del_lst:
                conn_lst.remove(del_item)

import time
import socket
import threading
def func():
    sk = socket.socket()
    sk.connect(('127.0.0.1',8080))
    time.sleep(1)
    sk.send(b'hello')
    print(sk.recv(1024).decode('utf-8'))
    sk.close()

for i in range(10):
    threading.Thread(target=func).start()

但是非阻塞IO模型不被推荐

优点：能够在等待任务完成的时间里干其他活了（包括提交其他任务，也就是后台可以有多个任务在同时执行）

缺点：循环调用recv()将大幅度推高CPU占用率，这也是要time.sleep的原因，否则很容易卡机情况。

　　    任务完成的响应延迟增大了，因为每过一段时间才去轮询一次read操作，而任务可能在两次轮询之间的任意时间完成。这会导致整体数据吞吐量的降低。

此外这个方案中recv()更多的是起到检测操作是否完成的作用，实际操作系统提供了更为高效的检测操作是否完成作用的接口，例如select()多路复用模式，可以一次检测多个连接是否活跃。

多路复用IO

多路利用IO也称为事件驱动IO，常用的模型有select、poll、epoll，好处在于单个process就可以同时处理多个网络连接的IO。它的基本原理就是function会不断的轮询所负责的socket，当某个socket有数据到达了，就通知用户进程。

重点：

　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的优势在于可以处理多个连接，不适用于单个连接

import select
import socket
sk = socket.socket()
sk.bind(('127.0.0.1',8080))
sk.listen()
read_lst = [sk]
while True:
    rl,wl,xl = select.select(read_lst,[],[]) # select阻塞,rl可以读的 wl可以写的 xl可以改的  [sk,conn]
    for item in rl:
        if item == sk:
            conn,addr = item.accept()
            read_lst.append(conn)
        else:
            ret = item.recv(1024).decode('utf-8')
            if not ret:
                item.close()
                read_lst.remove(item)
            else:
                print(ret)
                item.send(('received %s'%ret).encode('utf-8'))

import time
import socket
import threading
def client_async(arg):
    sk = socket.socket()
    sk.connect(('127.0.0.1',8080))
    for i in range(10):
        time.sleep(2)
        sk.send(('%s[%s] :hello'%(arg,i)).encode('utf-8'))
        ret = sk.recv(1024).decode('utf-8')
        print(ret)
    sk.close()

for i in range(10):
    threading.Thread(target=client_async,args=('*'*i,)).start()

select 监听fd变化的过程分析：

用户进程创建socket对象，拷贝监听fd到内核空间，每一个fd会对应一张系统文件表，内核空间的fd响应到数据后，就会发送信号给用户进程数据已到。

用户进程再发送系统调用，比如（accept）将内核空间的数据copy到用户空间，同时作为接受数据端内核空间的数据清除，这样重新监听时fd再有新的数据又可以响应到了（发送端因为基于TCP协议所以需要收到应答后才会清除）。

该模型的优点：

相比其他模型，使用select()的事件驱动模型只用单线程（进程）执行，占用资源少，不消耗太多CPU同时能够为多客户端提供服务。如果试图建立一个简单的事件驱动的服务程序，这个模型有一定的参考价值。

该模型的缺点：

首先select()接口并不实现事件驱动的最好选择。因为当需要探测的句柄值较大时，select()接口本身需要消耗大量时间去轮询各句柄。

很多操作系统提供了更为高效的接口，如linux提供了epoll，BSD提供了kqueue，Solaris提供了/dev/poll

所以使用类似于epoll的接口和事响应夹杂在一起，一旦事件响应的执行体庞大，则对整个模型是灾难性的。

IO模型比较分析

到目前为止，已经将四个IO Model都介绍完了。现在回过头来回答最初的那几个问题：blocking和non-blocking的区别在哪，synchronous IO和asynchronous IO的区别在哪。
    先回答最简单的这个：blocking vs 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并没有被block啊。这里有个非常“狡猾”的地方，定义中所指的”IO operation”是指真实的IO操作，就是例子中的recvfrom这个system call。non-blocking IO在执行recvfrom这个system call的时候，如果kernel的数据没有准备好，这时候不会block进程。但是，当kernel中数据准备好的时候，recvfrom会将数据从kernel拷贝到用户内存中，这个时候进程是被block了，在这段时间内，进程是被block的。而asynchronous IO则不一样，当进程发起IO 操作之后，就直接返回再也不理睬了，直到kernel发送一个信号，告诉进程说IO完成。在这整个过程中，进程完全没有被block。

    各个IO Model的比较如图所示：

　　

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

selectors模块

from socket import *
import selectors

sel=selectors.DefaultSelector()   # 创建一个默认的多路复用模型
def accept(sk):
    conn,addr=sk.accept()
    sel.register(conn,selectors.EVENT_READ,read)

def read(conn):
    try:
        data=conn.recv(1024)
        if not data:   #win8 win10
            print('closing',conn)
            sel.unregister(conn)
            conn.close()
            return
        conn.send(data.upper()+b'_SB')
    except Exception:    # linux操作系统
        print('closing', conn)
        sel.unregister(conn)
        conn.close()

sk=socket(AF_INET,SOCK_STREAM)
sk.setsockopt(SOL_SOCKET,SO_REUSEADDR,1)
sk.bind(('127.0.0.1',8088))
sk.listen(5)
sk.setblocking(False) #设置socket的接口为非阻塞
sel.register(sk,selectors.EVENT_READ,accept) #相当于网select的读列表里append了一个文件句柄server_fileobj,并且绑定了一个回调函数accept

while True:
    events=sel.select() #检测所有的fileobj，是否有完成wait data的   #[sk,conn]
    for sel_obj,mask in events:   # 有人触动了你在sel当中注册的对象
        callback=sel_obj.data #callback=accpet   # sel_obj.data就能拿到当初注册的时候写的accept/read方法
        callback(sel_obj.fileobj) #accpet(sk)/read(conn)

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

#服务端
from socket import *
import selectors

sel=selectors.DefaultSelector()
def accept(server_fileobj,mask):
    conn,addr=server_fileobj.accept()
    sel.register(conn,selectors.EVENT_READ,read)

def read(conn,mask):
    try:
        data=conn.recv(1024)
        if not data:
            print('closing',conn)
            sel.unregister(conn)
            conn.close()
            return
        conn.send(data.upper()+b'_SB')
    except Exception:
        print('closing', conn)
        sel.unregister(conn)
        conn.close()



server_fileobj=socket(AF_INET,SOCK_STREAM)
server_fileobj.setsockopt(SOL_SOCKET,SO_REUSEADDR,1)
server_fileobj.bind(('127.0.0.1',8088))
server_fileobj.listen(5)
server_fileobj.setblocking(False) #设置socket的接口为非阻塞
sel.register(server_fileobj,selectors.EVENT_READ,accept) #相当于网select的读列表里append了一个文件句柄server_fileobj,并且绑定了一个回调函数accept

while True:
    events=sel.select() #检测所有的fileobj，是否有完成wait data的
    for sel_obj,mask in events:
        callback=sel_obj.data #callback=accpet
        callback(sel_obj.fileobj,mask) #accpet(server_fileobj,1)

#客户端
from socket import *
c=socket(AF_INET,SOCK_STREAM)
c.connect(('127.0.0.1',8088))

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