python笔记(IO模型)

一、IO模型：
1、blocking IO 阻塞IO
server端：

import socket
sk = socket.socket()
sk.bind(('127.0.0.1',8080))
sk.setblocking(False)   #把socket当中所有需要阻塞的方法改成非阻塞：recv,recvfrome,accept
sk.listen(5)
conn_l = []  #用来存储所有来请求server端的conn连接
del_conn = [] #用来存储所有已断开与server端连接的conn
while True:
    try:
        conn,addr = sk.accept()  #陷入阻塞（1步）
        print('建立连接',addr)
        conn_l.append(conn)
    except BlockingIOError:
        for con in conn_l:
            try:
                msg = con.recv(1024)
                if msg == b'':
                    del_conn.append(con)
                    continue   #结束本次循环
                print(msg)
                con.send(b'bye')
            except BlockingIOError:pass
        for con in del_conn:
            con.close()
            conn_l.remove(con)
        del_conn.clear()

输出结果：

建立连接 (‘127.0.0.1’, 49396)
建立连接 (‘127.0.0.1’, 49395)
建立连接 (‘127.0.0.1’, 49397)
建立连接 (‘127.0.0.1’, 49398)
建立连接 (‘127.0.0.1’, 49399)
建立连接 (‘127.0.0.1’, 49400)
建立连接 (‘127.0.0.1’, 49401)
建立连接 (‘127.0.0.1’, 49402)
建立连接 (‘127.0.0.1’, 49403)
b’world’
b’world’
b’world’
b’world’
b’world’
b’world’
b’world’
b’world’
b’world’
建立连接 (‘127.0.0.1’, 49404)
b’world’
client端：

client端

import time
import socket
import threading
def func():
    sk = socket.socket()
    sk.connect(('127.0.0.1',8080))
    sk.send(b'world')
    time.sleep(1)
    print(sk.recv(1024))
    sk.close()
for i in range(10):
    threading.Thread(target=func).start()

输出结果：

b’bye’
b’bye’
b’bye’
b’bye’
b’bye’
b’bye’
b’bye’
b’bye’
b’bye’
b’bye’

2、nonblocking IO 非阻塞IO
3、IO multiplexing IO多路复用
（1）select机制 Windows linux 都是操作系统轮询每一个被监听的项，看是否有操作
（2）poll机制 linux 它可以监听的对象比select机制可以监听的多，随着监听的项越多运行速度就越慢。
（3）epoll机制 linux
server端：

import select
import socket
sk = socket.socket()
sk.bind(('127.0.0.1',8080))
sk.setblocking(False)
sk.listen(5)
read_list = [sk]
while True:
    r_list,w_list,x_list = select.select(read_list,[],[])
    for i in r_list:
        if i is sk:
            conn,addr = i.accept()
            read_list.append(conn)
        else:
            ret = i.recv(1024)
            if ret == b'':
                i.close()
                read_list.remove(i)
                continue
            print(ret)
            i.send(b'bey')

输出结果：

b’hello’
b’hello’
b’hello’
b’hello’
b’hello’
client端：

  import socket
import time
import threading
def func():
    sk = socket.socket()
    sk.connect(('127.0.0.1',8080))
    sk.send(b'hello')
    time.sleep(3)
    print(sk.recv(1024))
    sk.close()
for i in range(5):
    threading.Thread(target=func).start()

输出结果：

b’bey’
b’bey’
b’bey’
b’bey’
b’bey’

4、signal driven IO 信号驱动IO
5、asynchronous IO 异步IO

同步 提交一个任务之后要等待这个任务执行完毕
异步 只管提交任务，不等待这个任务执行完毕就可以做其他事情
阻塞 recv recvfrom accept
非阻塞

阻塞 线程 运行状态–>阻塞状态–>就绪
非阻塞