035_IO 模型

IO 模型分类

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

1，阻塞IO 的图

　　recv数据

　　阻塞IO

　　非阻塞IO

 

　　IO多路复用

2，

　　阻塞IO    ： 工作效率低
　　非阻塞IO  ： 工作效率高，频繁询问切换加大CPU的负担
　　IO多路复用： 在有多个对象需要IO阻塞的时候，能够有效的减少阻塞带来的时间损耗，且能够在一定程度上减少CPU的负担
　　异步IO : asyncio  异步IO  工作效率高 CPU的负担少

3，网络IO

       # recv     recvfrom   accept   requests.get()
       # send    connect    sendto

4，IO的两个阶 段

       # 数据准备阶段
       # 数据copy阶段

 

解决阻塞IO 问题

   1）多进程 多线程 分离了阻塞
　　　　但进程线程不能无限开！
   2）以后用进程都用进程池
　　　　单纯的进程池不能满足用户的需求，只适合小并发的问题，真正需要我们解决的是I/O问题

1，非阻塞IO实例

import socket
sk = socket.socket()
sk.bind(('127.0.0.1',8080))
sk.listen()
sk.setblocking(False)    
 # 异步的，但是来不及打开client端建立连接，就已经报错
# 因为下一句不阻塞了
# recv 也不阻塞了，但一样会报错 ，有连接时，且设为不阻塞时，没消息就打印空消息。
# 原因：调用阻塞异常错误（变量没有被赋值）
conn,addr = sk.accept()
print(conn)

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)   # 不将建立成功的连接用列表保存下来，conn会不断被新连接覆盖。
    except BlockingIOError:
        del_lst = []
        for c in conn_lst:    
            try:
                msg = c.recv(10).decode('utf-8')  # recv不会阻塞
                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'hi')
    print(sk.recv(10))
    sk.close()

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

多路复用

# 操作系统提供的多路复用机制
      #  select  、 poll 、  epoll、
      # windows 上只有 select
      # linux 兼容三种

　　# 原来是recv，现在是交给select ；select([recv])

1，参数

　　select(rlist,wlisr,xlist,timeout = None)
          　　等能  读，写，改   三个参数是列表，必须传参，没有参数传空列表。返回的结果是一个有三个列表的元组，分别是读，写，改的结果。

2，实例

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

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

import socket
import select
sk = socket.socket()
sk.bind(('127.0.0.1',8099))
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'))

3，

# select poll 随着要检测的数据增加 效率会下降，不适合处理大并发。

# select  有数目的限制
# poll    能处理的对象更多
# epoll   能处理多对象且 不是使用轮询  而是用回调函数 —— linux

#这三种IO多路复用模型在不同的平台有着不同的支持，而epoll在windows下就不支持，好在我们有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)