IO分类
IO分类：阻塞IO，非阻塞IO,IO多路复用，异步IO等
阻塞IO
- 定义：在执行IO操作时如果执行条件不满足则阻塞。阻塞IO是IO的默认形态。
- 效率：阻塞IO是效率很低的一种IO。但是由于逻辑简单所以是默认IO行为。
- 阻塞情况：
- 因为某种执行条件没有满足造成的函数阻塞
如：accept input recv等
- 处理IO的时间较长产生的阻塞状态
如：网络传输，大文件读写等
非阻塞IO
- 定义：通过修改IO属性行为，使原本阻塞的IO变为非阻塞的状态
- 设置套接字为非阻塞IO
sockfd.setblocking(bool)
功能：设置套接字为非阻塞IO
参数：默认为True，表示套接字IO阻塞；设置为False则套接字IO变为非阻塞
- 超时检测：设置一个最长阻塞时间，超过该时间后则不再阻塞等待。
sockfd.settimeout(sec)
功能：设置套接字的超时时间
参数：设置的时间
代码示例：
1 from socket import * 2 from time import * 3 4 # 日志文件 5 f = open('log.txt','a+') 6 7 # tcp 服务端 8 sockfd = socket() 9 sockfd.bind(('0.0.0.0',8888)) 10 sockfd.listen(5) 11 12 # 非阻塞设置 13 # sockfd.setblocking(False) 14 15 # 超时时间 16 sockfd.settimeout(2) 17 18 19 while True: 20 print("Waiting from connect...") 21 try: 22 connfd,addr = sockfd.accept() 23 except (BlockingIOError,timeout) as e: 24 sleep(2) 25 f.write("%s : %s\n"%(ctime(),e)) 26 f.flush() 27 else: 28 print("Connect from",addr) 29 data = connfd.recv(1024).decode() 30 print(data)
IO多路复用
- 定义
同时监控多个IO事件，当那个IO事件准备就绪就执行哪个IO事件。以此形成可以同时处理多个IO的行为，避免一个IO阻塞造成其他IO均无法执行，提高了IO执行效率。
- 具体方案
select方法：Windows Linux unix
poll方法：Linux unix
epoll方法：Linux
select方法
rs, ws, xs=select(rlist, wlist, xlist[, timeout])
功能: 监控IO事件，阻塞等待IO发生
参数：rlist 列表 存放关注的等待发生的IO事件
wlist 列表 存放关注的要主动处理的IO事件
xlist 列表 存放关注的出现异常要处理的IO
timeout 超时时间
返回值： rs 列表 rlist中准备就绪的IO
ws 列表 wlist中准备就绪的IO
xs 列表 xlist中准备就绪的IO代码示例：
1 from select import select 2 from socket import * 3 4 s = socket() 5 s.bind(('0.0.0.0',8888)) 6 s.listen(3) 7 8 f = open('log.txt','r+') 9 10 print("开始监控ＩＯ") 11 rs,ws,xs = select([s],[],[]) 12 print(rs) 13 print(ws) 14 print(xs)
select实现TCP服务
【1】 将关注的IO放入对应的监控类别列表
【2】通过select函数进行监控
【3】遍历select返回值列表，确定就绪IO事件
【4】处理发生的IO事件
注意
- wlist中如果存在IO事件，则select立即返回给ws
- 处理IO过程中不要出现死循环占有服务端的情况
- IO多路复用消耗资源较少，效率较高
select tcp代码示例：
1 from socket import * 2 from select import select 3 4 # 创建监听套接字 5 s = socket() 6 s.setsockopt(SOL_SOCKET,SO_REUSEADDR,1) 7 s.bind(('0.0.0.0',8888)) 8 s.listen(5) 9 10 # 设置关注的ＩＯ列表 11 rlist = [s] # ｓ 用于等待处理连接 12 wlist = [] 13 xlist = [] 14 15 # 循环ＩＯ监控 16 while True: 17 # print("++++",rlist) 18 rs,ws,xs = select(rlist,wlist,xlist) 19 # print('----',rs) 20 # 遍历返回值列表，判断哪个ＩＯ就绪 21 for r in rs: 22 if r is s: 23 c,addr = r.accept() 24 print("Connect from",addr) 25 rlist.append(c) # 增加新的关注的ＩＯ 26 else: 27 # 表明有客户端发送消息 28 data = r.recv(1024).decode() 29 print(data) 30 r.send(b'OK') 31 32 for w in ws: 33 pass 34 35 for x in xs: 36 pass
poll方法
p = select.poll()
功能 ： 创建poll对象
返回值： poll对象
p.register(fd,event)
功能: 注册关注的IO事件
参数：fd 要关注的IO
event 要关注的IO事件类型
常用类型：POLLIN 读IO事件（rlist）
POLLOUT 写IO事件 (wlist)
POLLERR 异常IO （xlist）
POLLHUP 断开连接
e.g. p.register(sockfd,POLLIN|POLLERR)
p.unregister(fd)
功能：取消对IO的关注
参数：IO对象或者IO对象的fileno
events = p.poll()
功能： 阻塞等待监控的IO事件发生
返回值： 返回发生的IO
events格式 [(fileno,event),()....]
每个元组为一个就绪IO，元组第一项是该IO的fileno，第二项为该IO就绪的事件类型poll步骤
【1】 创建套接字
【2】 将套接字register
【3】 创建查找字典，并维护
【4】 循环监控IO发生
【5】 处理发生的IO
poll代码示例：
1 from socket import * 2 from select import * 3 4 # 创建监听套接字，作为关注的ＩＯ 5 s = socket() 6 s.setsockopt(SOL_SOCKET,SO_REUSEADDR,1) 7 s.bind(('0.0.0.0',8888)) 8 s.listen(3) 9 10 # 创建ｐｏｌｌ对象 11 p = poll() 12 13 # 建立查找字典，通过ＩＯ的fileno查找io对象 14 # 始终与ｒｅｇｉｓｔｅｒ的ＩＯ保持一直 15 fdmap = {s.fileno():s} 16 17 # 关注 ｓ 18 p.register(s,POLLIN|POLLERR) 19 20 # 循环监控ＩＯ发生 21 while True: 22 events = p.poll() # 阻塞等待ＩＯ发生 23 # 循环遍历查看哪个ＩＯ准备就绪 24 for fd,event in events: 25 print(events) 26 if fd == s.fileno(): 27 c,addr = fdmap[fd].accept() 28 print("Connect from",addr) 29 # 关注客户端连接套接字 30 p.register(c,POLLIN|POLLHUP) 31 fdmap[c.fileno()] = c # 维护字典 32 elif event & POLLIN: 33 data = fdmap[fd].recv(1024).decode() 34 if not data: 35 p.unregister(fd) # 取消监控 36 fdmap[fd].close() 37 del fdmap[fd] # 从字典删除 38 continue 39 print(data) 40 p.register(fdmap[fd],POLLOUT) 41 elif event & POLLOUT: 42 fdmap[fd].send(b'OK') 43 p.register(fdmap[fd], POLLIN)
epoll方法
使用方法：
- 基本与poll相同
- 生成对象改为epoll()
- 将所有事件类型改为EPOLL类型
epoll特点
- epoll效率比select poll要高
- epoll监控IO数量方式比poll要多
- epoll的触发方式比poll要多（EPOLLET边缘触发）
epoll完成tcp并发代码示例：
1 from socket import * 2 from select import * 3 4 # 创建监听套接字，作为关注的ＩＯ 5 s = socket() 6 s.setsockopt(SOL_SOCKET,SO_REUSEADDR,1) 7 s.bind(('0.0.0.0',8888)) 8 s.listen(3) 9 10 # 创建eｐｏｌｌ对象 11 ep = epoll() 12 13 # 建立查找字典，通过ＩＯ的fileno查找io对象 14 # 始终与ｒｅｇｉｓｔｅｒ的ＩＯ保持一直 15 fdmap = {s.fileno():s} 16 17 # 关注 ｓ 18 ep.register(s,EPOLLIN|EPOLLERR) 19 20 # 循环监控ＩＯ发生 21 while True: 22 events = ep.poll() # 阻塞等待ＩＯ发生 23 print("你有新的ＩＯ需要处理哦") 24 # 循环遍历查看哪个ＩＯ准备就绪 25 for fd,event in events: 26 print(events) 27 if fd == s.fileno(): 28 c,addr = fdmap[fd].accept() 29 print("Connect from",addr) 30 # 关注客户端连接套接字 31 ep.register(c,EPOLLIN|EPOLLET) # 设置边缘触发 32 fdmap[c.fileno()] = c # 维护字典 33 # elif event & EPOLLIN: 34 # data = fdmap[fd].recv(1024).decode() 35 # if not data: 36 # ep.unregister(fd) # 取消监控 37 # fdmap[fd].close() 38 # del fdmap[fd] # 从字典删除 39 # continue 40 # print(data) 41 # ep.unregister(fd) # 先取消关注再重新添加 42 # ep.register(fdmap[fd], EPOLLOUT) 43 # elif event & POLLOUT: 44 # fdmap[fd].send(b'OK') 45 # ep.unregister(fd) 46 # ep.register(fdmap[fd], EPOLLIN)
协程技术
基础概念
- 定义：纤程，微线程。是允许在不同入口点不同位置暂停的计算机程序，简单来说，协程就是可以暂停执行的函数。
- 协程原理：记录一个函数的上下文，协程调度切换时会将记录的上下文保存，在切换回来时进行调取，恢复原有的执行内容，以便从上一次执行位置继续执行
- 协程优缺点：
优点：
- 协程完成多任务占用计算资源很少
- 由于协程的多任务切换在应用层完成，因此切换开销少
- 协程为单线程程序，无需进行共享资源同步互斥处理
缺点：
- 协程的本质是一个单线程，无法利用计算机多核资源
扩展延申@标准库协程的实现
python3.5以后，使用标准库asyncio和async/await 语法来编写并发代码。asyncio库通过对异步IO行为的支持完成python的协程。虽然官方说asyncio是未来的开发方向，但是由于其生态不够丰富，大量的客户端不支持awaitable需要自己去封装，所以在使用上存在缺陷。更多时候只能使用已有的异步库（asyncio等），功能有限。
第三方协程模块
greenlet模块
- 安装：sudo pip3 install greenlet
- 函数
greenlet.greenlet(func)
功能：创建协程对象
参数：协程函数
g.switch()
功能：选择要执行的协程函数协程行为代码示例：
1 from greenlet import greenlet 2 3 def fun1(): 4 print("执行 fun1") 5 gr2.switch() 6 print("结束 fun1") 7 gr2.switch() 8 9 def fun2(): 10 print("执行 fun2") 11 gr1.switch() 12 print("结束 fun2") 13 14 # 将函数变为协程 15 gr1 = greenlet(fun1) 16 gr2 = greenlet(fun2) 17 18 gr1.switch() # 选择执行的协程函数
gevent模块
安装：sudo pip3 install gevent
函数：
gevent.spawn(func,argv)
功能: 生成协程对象
参数：func 协程函数
argv 给协程函数传参（不定参）
返回值： 协程对象
gevent.joinall(list,[timeout])
功能: 阻塞等待协程执行完毕
参数：list 协程对象列表
timeout 超时时间
gevent.sleep(sec)
功能: gevent睡眠阻塞
参数：睡眠时间
* gevent协程只有在遇到gevent指定的阻塞行为时才会自动在协程之间进行跳转
如gevent.joinall(),gevent.sleep()带来的阻塞gevent生成协程示例：
1 import gevent 2 from gevent import monkey 3 monkey.patch_time() # 修改对time模块中阻塞的解释行为 4 from time import sleep 5 6 # 协程函数 7 def foo(a,b): 8 print("Running foo ...",a,b) 9 # gevent.sleep(3) 10 sleep(3) 11 print("Foo again..") 12 13 def bar(): 14 print("Running bar ...") 15 # gevent.sleep(2) 16 sleep(2) 17 print("Bar again..") 18 19 # 生成协程对象 20 f = gevent.spawn(foo,1,2) 21 g = gevent.spawn(bar) 22 23 gevent.joinall([f,g]) #阻塞等待f,g代表的协程执行完毕
基于协程的TCP开发代码示例：
1 import gevent 2 from gevent import monkey 3 monkey.patch_all() # 执行脚本,修改socket 4 from socket import * 5 6 def handle(c): 7 while True: 8 data = c.recv(1024).decode() 9 if not data: 10 break 11 print(data) 12 c.send(b'OK') 13 c.close() 14 15 # 创建tcp套接字 16 s = socket() 17 s.setsockopt(SOL_SOCKET,SO_REUSEADDR,1) 18 s.bind(('0.0.0.0',8888)) 19 s.listen(5) 20 21 # 循环接收来自客户端连接 22 while True: 23 c,addr = s.accept() 24 print("Connect from",addr) 25 # handle(c) # 处理具体客户端请求 26 gevent.spawn(handle,c) # 协程方案
- monkey脚本
作用：在gevent协程中，协程只有遇到gevent指定类型的阻塞才能跳转到其他协程，因此，我们希望将普通IO阻塞行为转换为可以触发gevent协程跳转的阻塞，以提高执行效率。
转换方法：gevent提供了一个脚本程序monkey，可以修改底层解释IO阻塞的行为，将很多普通阻塞转换为gevent阻塞。
使用方法
【1】 导入monkey
from gevent import monkey
【2】 运行相应的脚本，例如转换socket中所有阻塞
monkey.patch_socket()
【3】 如果将所有可转换的IO阻塞全部转换则运行all
monkey.patch_all()
【4】 注意：脚本运行函数需要在对应模块导入前执行基于协程的TCP开发代码示例：
1 """ 2 思路 : 1. 每个客户函数端设置为协成 3 2. 将socket模块下的阻塞变为可以触发协程跳转 4 """ 5 import gevent 6 from gevent import monkey 7 monkey.patch_all() # 执行脚本,修改socket 8 from socket import * 9 10 def handle(c): 11 while True: 12 data = c.recv(1024).decode() 13 if not data: 14 break 15 print(data) 16 c.send(b'OK') 17 c.close() 18 19 # 创建tcp套接字 20 s = socket() 21 s.setsockopt(SOL_SOCKET,SO_REUSEADDR,1) 22 s.bind(('0.0.0.0',8888)) 23 s.listen(5) 24 25 # 循环接收来自客户端连接 26 while True: 27 c,addr = s.accept() 28 print("Connect from",addr) 29 # handle(c) # 处理具体客户端请求 30 gevent.spawn(handle,c) # 协程方案
扩展：位运算
定义：将整数转换为二进制，按二进制位进行运算
运算符号：
& 按位与
| 按位或
^ 按位异或
<< 左移
>> 右移
14 --> 01110
19 --> 10011
14 & 19 = 00010 = 2 一0则0
14 | 19 = 11111 = 31 一1则1
14 ^ 19 = 11101 = 29 相同为0不同为1
14 << 2 = 111000 = 56 向左移动低位补0
14 >> 2 = 11 = 3 向右移动去掉低位
扫一扫
1399
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
