IO模型、阻塞IO模型、非阻塞IO模型、多路复用、异步IO

【IO模型】

Stevens一共有5种IO Model:
　　1.blocking IO 阻塞  -------------常见的网络阻塞状态：accept、recv、recvfrom

　　2.nonblocking IO 非阻塞
　　3.IO multiplexing IO多路复用
　　4.signal driven IO 信号驱动IO
　　5.asynchronous IO 异步IO
　　　　由signal driven IO(信号驱动IO)在实际中并不常用，所以主要介绍剩下的四种IO Model(IO多路复用、异步IO)。

 

（阻塞IO模型）

 

import socket

server = socket.socket()
server.bind(('127.0.0.1', 6969))
server.listen(5)

while True:
    conn, addr = server.accept()
    while True:
        try:
            data = conn.recv(1024)
            if len(data) == 0: break
            print(data)
            conn.send(data.upper())
        except ConnectionResetError as e:
            break
    conn.close()
# 在服务端开设多进程或者多线程，其实还是没有解决IO问题，该等的地方还是在等，没有规避，只不过多个人等待的彼此过程中互不干扰

 

（非阻塞IO模型）

虽然非阻塞IO看起来非常的厉害，但该模型会长时间占用CPU不干活，让CPU处于空转的状态，

 

服务端

import socket, time

server = socket.socket()
server.bind(('127.0.0.1', 8888))
server.listen(5)
server.setblocking(True)  # 设置阻塞
# 如果（）内为False，则表示将所有的网络阻塞变为非阻塞，

r_list = []
del_list = []
while True:
    try:
        conn, addr = server.accept()  # 立马阻塞
        r_list.append(conn)
    except BlockingIOError as e:
        # time.sleep(2)
        # print('列表的长度:',len(r_list))
        # print('做其他事情')
        for conn in r_list:
            try:
                data = conn.recv(1024)  # 没有消息  报错
                if len(data) == 0:  # 客户端断开链接
                    conn.close()
                    # 将无用的conn从r_list删除
                    del_list.append(conn)
                    continue
　　　　　　　　　　　　conn.send(data.upper()

            except BlockingIOError:
                continue
            except ConnectionResetError:
                conn.close()
                del_list.append(conn)
        # 挥手无用链接
        for conn in del_list:
            r_list.remove(conn)
        del_list.remove(conn)

=================================
客户端

import socket

client = socket.socket()
client.connect(('127.0.0.1', 8888))

while True:
    msg = input('>>>:')
    client.send(b'hello world')
    data = client.recv(1024)
    print(data)

 

（多路复用）

当监管的对象只有一个的时候 其实IO多路复用连阻塞IO都比比不上!!!但是IO多路复用可以一次性监管很多个对象
监管机制是操作系统本身就有的 如果你想要用该监管机制(select)需要你导入对应的selectors模块

总结：
监管机制由很多
select机制 window linux都有
poll机制 只有linux有,poll机制和select机制基本一样，都可以监管多个对象，但是poll机制没有最大连接数的限制，在监管的时候肯会出现延时相应
epoll机制 只有linux有，给每个监管机制对象都绑定了一个回调机制，一旦有响应，回调机制立马发起提醒

 

服务端

import socket, select

server = socket.socket()
server.bind(('127.0.0.1', 8001))
server.listen(5)
server.setblocking(False)  # 设置阻塞
read_list = [server]
while True:
    r_list, w_list, x_list, = select.select(read_list, [], [])
    for i in r_list:
        if i is server:
            conn, addr = i.accept()
            # 也该添加到监管的队列中
            read_list.append(conn)
        else:
            res = i.recv(1024)
            if len(res) == 0:
                i.close()
                # 将无效的监管对象移除
                read_list.remove(i)
                continue
            print(res)
            i.send(b'OK')


============================================
客户端

import socket

client = socket.socket()
client.connect(('127.0.0.1', 8001))

while True:
    38     client.send(b'hello world')
    data = client.recv(1024)
    print(data)

(异步IO)

异步IO模型是所有模型中效率最高的 也是使用最广泛的相关的模块和框架
模块:asyncio模块
异步框架:sanic、tronado、twisted
速度快

 

import threading, asyncio


@asyncio.coroutine
def hello():
    print('Hello world!%s' % threading.current_thread())
    # 异步调用asyncio.sleep(1)
    yield from asyncio.sleep(1)
    print('Hello world%s' % threading.current_thread())


loop = asyncio.get_event_loop()
tasks = [hello(), hello()]
loop.run_until_complete(asyncio.wait(tasks))
loop.close()

总结