小白对异步IO的理解
前言
看到越来越多的大佬都在使用python的异步IO,协程等概念来实现高效的IO处理过程,可是我对这些概念还不太懂,就学习了一下。 因为是初学者,在理解上有很多不到位的地方,如果有错误,还希望能够有人积极帮我指出。
下面就使用一个简单的爬虫的例子,通过一步一步的改进,最后来用异步IO的方式实现。
1. 阻塞的IO
我们要实现一个爬虫,去爬百度首页n次,最简单的想法就是依次下载,从建立socket连接到发送网络请求再到读取响应数据,顺序进行。
代码如下:
import time
import socket
import sys def doRequest():
sock = socket.socket()
sock.connect(('www.baidu.com',80))
sock.send("GET / HTTP/1.1\r\nHost: www.baidu.com\r\nConnection: Close\r\n\r\n".encode("utf-8"))
response = sock.recv(1024)
return response def main():
start = time.time()
for i in range(int(sys.argv[1])):
doRequest()
print("spend time : %s" %(time.time()-start)) main()
因为socket是阻塞方式调用的,所以cpu执行到sock.connect()
,sock.recv()
,就会一直卡在那里直到socket的状态就绪,所以浪费了很多的CPU时间。
请求10次和20次的时间分别如下所示:
➜ python3 1.py 10
spend time : 0.9282660484313965
➜ python3 1.py 20
spend time : 1.732438087463379
可以看到,速度慢的跟蜗牛一样。
2. 改进1-并发
为了加快请求的速度,很容易想到我们可以使用并发的方式进行,那么最好的方式就是使用多线程了。修改后的代码如下:
# 多线程 import time
import socket
import sys
import threading def doRequest():
sock = socket.socket()
sock.connect(('www.baidu.com',80))
sock.send("GET / HTTP/1.1\r\nHost: www.baidu.com\r\nConnection: Close\r\n\r\n".encode("utf-8"))
response = sock.recv(1024)
return response def main():
start = time.time()
threads = []
for i in range(int(sys.argv[1])):
# doRequest()
threads.append(threading.Thread(target=doRequest,args=()))
for i in threads:
i.start()
for i in threads:
i.join()
print("spend time : %s" %(time.time()-start))
使用线程之后,看一下请求10次和20次的时间:
➜ python3 2.py 10
spend time : 0.1124269962310791
➜ python3 2.py 20
spend time : 0.15438294410705566
速度明显快了很多,几乎是刚才的10倍了。
但是python的线程是有问题的,因为一个python进程中,同一时刻只允许一个线程运行,正在执行的线程会获取到GPL。做阻塞的系统调用时,例如sock.connect()
,sock.recv()
时,当前线程会释放GIL,让别的线程有机会获取GPL,然后执行。但是这种获取GPL的调度策略是抢占式的,以保证同等优先级的线程都有均等的执行机会,那带来的问题是:并不知道下一时刻是哪个线程被运行,也不知道它正要执行的代码是什么。所以就可能存在竞态条件。这种竞争有可能使某些线程处于劣势,导致一直获取不到GPL
比如如下的情况,线程1执行的代码如下:
flag = True
while flag:
..... # 这里省略一些复杂的操作,会调用多次IO操作
time.sleep(1)
可以看到,线程1的任务非常简单,而线程2的任务非常复杂,这就会导致CPU不停地去执行线程1,而真正做实际工作的线程2却很少被调度到,导致了浪费了大量的CPU资源。
3. 改进2-非阻塞方式
在第一个例子中,我们意识到浪费了大量的时间,是因为我们用了阻塞的IO,导致CPU在卡在那里等待IO的就绪,那使用非阻塞的IO,是不是就可以解决这个问题了。
代码如下:
import time
import socket
import sys def doRequest():
sock = socket.socket()
sock.setblocking(False)
try:
sock.connect(('www.baidu.com',80))
except BlockingIOError:
pass # 因为设置为非阻塞模式了,不知道何时socket就绪,需要不停的监控socket的状态
while True:
try:
sock.send("GET / HTTP/1.1\r\nHost: www.baidu.com\r\nConnection: Close\r\n\r\n".encode("utf-8"))
# 直到send 不抛出异常,就发送成功了
break
except OSError:
pass
while True:
try:
response = sock.recv(1024)
break
except OSError:
pass
return response
def main():
start = time.time()
for i in range(int(sys.argv[1])):
doRequest()
print("spend time : %s" %(time.time()-start)) main()
sock.setblocking(False)
把socket设置为非阻塞式的,也就是说执行完sock.connect()
和sock.recv()
之后,CPU不再等待IO了,会继续往下执行,来看一下执行时间:
➜ python3 3.py 10
spend time : 1.0597507953643799
➜ python3 3.py 20
spend time : 2.0327329635620117
感觉被骗了,速度还是跟第一个一样啊,看来非阻塞IO并没有什么速度上的提升啊,问题出在哪里呢?看代码发现多了两个while循环:
while True:
try:
sock.send("GET / HTTP/1.1\r\nHost: www.baidu.com\r\nConnection: Close\r\n\r\n".encode("utf-8"))
# 直到send 不抛出异常,就发送成功了
break
except OSError:
pass
while True:
try:
response = sock.recv(1024)
break
except OSError:
pass
因为把socket设置为非阻塞模式了,所以CPU并不知道IO什么时候就绪,所以必须在这里不停的尝试,直到IO可以使用了为止。
虽然 connect() 和 recv() 不再阻塞主程序,空出来的时间段CPU没有空闲着,但并没有利用好这空闲去做其他有意义的事情,而是在循环尝试读写 socket (不停判断非阻塞调用的状态是否就绪)。
有没有办法让CPU空闲出来的时间,不用来不停的询问IO,而是干别的更有意义的事情呢,等IO就绪后再通知CPU回来处理呢?当然有了,那就是回调。
4. 改进3-回调
操作系统已经把IO状态的改变封装成了事件,如可读事件、可写事件。并且可以为这些事件绑定处理函数。所以我们可以使用这种方式,为socket的IO状态的变化绑定处理函数,交给系统进行调动,这样就是回调方式。python的select模块支持这样的操作。
代码如下:
import socket
from selectors import DefaultSelector, EVENT_WRITE, EVENT_READ
import sys
selector = DefaultSelector()
stopped = False
urls_todo = [] class Crawler:
def __init__(self, url):
self.url = url
self.sock = None
self.response = b'' def fetch(self):
self.sock = socket.socket()
self.sock.setblocking(False)
try:
self.sock.connect(('www.baidu.com', 80))
except BlockingIOError:
pass
selector.register(self.sock.fileno(), EVENT_WRITE, self.connected) def connected(self, key, mask):
selector.unregister(key.fd)
get = 'GET {0} HTTP/1.0\r\nHost: www.baidu.com\r\n\r\n'.format(self.url)
self.sock.send(get.encode('ascii'))
selector.register(key.fd, EVENT_READ, self.read_response) def read_response(self, key, mask):
global stopped
# 如果响应大于4KB,下一次循环会继续读
chunk = self.sock.recv(4096)
if chunk:
self.response += chunk
else:
selector.unregister(key.fd)
urls_todo.remove(self.url)
if not urls_todo:
stopped = True def loop():
while not stopped:
# 阻塞, 直到一个事件发生
events = selector.select()
for event_key, event_mask in events:
callback = event_key.data
callback(event_key, event_mask) if __name__ == '__main__':
import time
start = time.time()
for i in range(int(sys.argv[1])):
urls_todo.append("/"+str(i))
crawler = Crawler("/"+str(i))
crawler.fetch()
loop()
print("spend time : %s" %(time.time()-start))
监控socket的状态,如果变为可写的,就往里面写数据
selector.register(self.sock.fileno(), EVENT_WRITE, self.connected)
监控socket的状态,如果变为可读的,就外读数据
selector.register(key.fd, EVENT_READ, self.read_response)
测试一下速度:
➜ python3 4.py 10
spend time : 0.03910994529724121
➜ python3 4.py 20
spend time : 0.04195284843444824
我们看到速度已经有个一个质的飞跃了,但是回调用一些严重的问题,会破坏代码的本来的逻辑结构,造成代码可读性很差。
比如我们有函数 funcA,funcB,funcC三个函数,如果funcC处理的结果依赖于funcB的处理结果,funcB的处理结果依赖于funcA的处理结果,而funcA又是回调的方式调用的,所以就不知道funcA什么时候返回,所以只能将后续的处理都作为callback的方式传入funcA中,让funcA执行完了可以执行funcB,funcB执行完了可以执行funcC,看起来像下面这样:
funcA(funcB(funcC()))
这就形成了一个链式的回调,跟最初的代码逻辑完全相反,本来的逻辑应该是这样的。
funcC(funcB(funcA()))
因为这样的链式回调的出现,导致了理解代码逻辑困难,并且错误处理困难。
有没有方法避免这种地狱式的链式回调的呢?
5 .改进4-利用生成器
可以利用python的生成器,把发请求的函数写成一个生成器,然后只监控IO的状态,当IO状态发生改变之后,就给生成器传送值,驱动生成器进行下一步操作,这样就可以避免回调了,具体实现如下:
import select
import socket
import time
import sys num = int(sys.argv[1]) def coroutine():
sock = socket.socket()
sock.setblocking(0)
address = yield sock
try:
sock.connect(address)
except BlockingIOError:
pass
data = yield
size = yield sock.send(data)
yield sock.recv(size) def main():
inputs = []
outputs = []
coros = []
coro_dict = dict()
for i in range(num):
coros.append(coroutine())
sock = coros[-1].send(None) # 发送一个None值来启动生成器
outputs.append(sock.fileno()) #
# print(outputs)
coro_dict[sock.fileno()] = coros[-1]
coros[-1].send(('www.baidu.com', 80))
while True:
r_list,w_list,e_list = select.select(inputs,outputs, ())
for i in w_list:
# print(type(i))
coro_dict[i].send(b'GET / HTTP/1.1\r\nHost: www.baidu.com\r\nConnection: Close\r\n\r\n')
outputs.remove(i)
inputs.append(i)
for i in r_list:
coro_dict[i].send(1024)
inputs.remove(i)
if len(inputs) == len(outputs) == 0:
break
# time.sleep(2)
# coro.send(b'GET / HTTP/1.1\r\nHost: www.baidu.com\r\nConnection: Close\r\n\r\n')
# select.select(wait_list, (), ())
# print(coro.send(1024)) start = time.time()
main()
print("spend time : %s" %(time.time()-start))
可以看到把发起请求的函数写成了一个生成器:
def coroutine():
sock = socket.socket()
sock.setblocking(0)
address = yield sock
try:
sock.connect(address)
except BlockingIOError:
pass
data = yield
size = yield sock.send(data)
yield sock.recv(size)
然后监控IO状态,当IO状态发生改变之后,驱动生成器继续运行。
while True:
r_list,w_list,e_list = select.select(inputs,outputs, ())
for i in w_list:
# print(type(i))
coro_dict[i].send(b'GET / HTTP/1.1\r\nHost: www.baidu.com\r\nConnection: Close\r\n\r\n')
outputs.remove(i)
inputs.append(i)
for i in r_list:
coro_dict[i].send(1024)
inputs.remove(i)
看一下程序执行时间:
➜ python3 5.py 10
spend time : 0.058114051818847656
➜ python3 5.py 20
spend time : 0.0949699878692627
效果貌似非常的棒啊,执行的太快了,但是当我执行300次请求的时候,我就发现问题了,返回的非常慢,。估计原因可能是select是顺序遍历每一个IO描述符的去做状态检查,当IO描述符过多的时候,会导致遍历的速度比较慢,所以造成时间花费很大。
小白对异步IO的理解的更多相关文章
- node中异步IO的理解
解释性语言和编译型语言的区别: 计算器不能直接的理解高级语言,只能理解机器语言,所以必须把高级语言翻译为机器语言,翻译的方式有两种,一个是编译,一个是解释. 解释性语言的程序不需要编译,它是在运行程序 ...
- python IO模式(多路复用和异步IO深入理解)
1.事件渠道模型.事件渠道为异步IO的原型. 2.IO模式,一次IO调用会经历两个阶段.一.等待数据阶段,将数据从网络或者是磁盘读取到系统内核(kennel) 二.将数据从内核拷贝到进程中. 基于这两 ...
- 同步IO, 异步IO的理解
1. 什么是IO? 在计算机中无时无刻不存在着对数据的访问和读取(数据都存储在物理的媒介上,例如寄存器,高速缓存,内存,磁盘,网卡等等),这些操作被称为IO. 2. 阻塞IO (1)当用户线程发起IO ...
- 自己动手写个异步IO函数 --(基于 c# Task)
前言 对于服务端,达到高性能.高扩展离不开异步.对于客户端,函数执行时间是1毫秒还是100毫秒差别不大,没必要为这一点点时间煞费苦心.对于异步,好多人还有误解,如: 异步就是多线程:异步就是如何 ...
- 【译】深入理解python3.4中Asyncio库与Node.js的异步IO机制
转载自http://xidui.github.io/2015/10/29/%E6%B7%B1%E5%85%A5%E7%90%86%E8%A7%A3python3-4-Asyncio%E5%BA%93% ...
- 深入理解非阻塞同步IO和非阻塞异步IO
这两篇文章分析了Linux下的5种IO模型 http://blog.csdn.net/historyasamirror/article/details/5778378 http://blog.csdn ...
- 伪异步IO理解
伪异步IO实在堵塞IO的基础上将每个client发送过来的请求由新创建的线程来处理改进为用线程池来处理.因此避免了为每个client请求创建一个新线程造成的资源耗尽问题. 来看一下伪异步IO的服务端代 ...
- Python-09-线程、进程、协程、异步IO
0. 什么是线程(thread)? 线程,有时被称为轻量级进程(Lightweight Process,LWP),是程序执行流的最小单元.一个标准的线程由线程ID,当前指令指针(PC),寄存器集合和堆 ...
- Mina、Netty、Twisted一起学(九):异步IO和回调函数
用过JavaScript或者jQuery的同学都知道,JavaScript特别是jQuery中存在大量的回调函数,例如Ajax.jQuery的动画等. $.get(url, function() { ...
随机推荐
- 【起航计划 021】2015 起航计划 Android APIDemo的魔鬼步伐 20 App->Intents createChooser
Intents 这个例子的代码非常简单: public void onGetMusic(View view) { Intent intent = new Intent(Intent.ACTION_GE ...
- SpringCloud的学习记录(1)
最近一段时间重新学习一边SpringCloud(有半年不用了),这里简单记录一下. 我用的是IntelliJ IDEA开发工具, SpringBoot的版本是2.1.3.RELEASE. 1. 构建M ...
- Java -GUI开发九九乘法表
Java GUI开发九九乘法表 (1)实现目标: 利用java自带的awt包,基础控件开发一个九九乘法表,点击可以显示对应的乘法口诀. (2)控件选择: 点击——Button 显示——TextFiel ...
- 前端怎样学习react
这是一个很长的话题.....慢慢写
- sql注入【手工及一些工具】
Sql注入原理分析: 网站程序存在可控传递参数,参数未进行过滤直接带入数据库查询,导致攻击者可通过传递恶意sql语句代码进行执行攻击. Sql注入产生条件 1.必须有参数传递 2.参数值带入数据库查询 ...
- 简单粗暴的更换固态硬盘及WIN10 Ubuntu双系统
简介:本文希望帮助如本人一样的计算机小白,能够以最快的速度更换固态硬盘及安装系统. 1.提前将准备空白U盘(至少8G),利用UltraISO工具,或者软媒魔方,制作U盘启动盘. PS:需提前下载好WI ...
- 如何使用事务码SMICM分析ABAP代码发起的HTTP请求的错误ICM_HTTP_SSL_PEER_CERT_UNTRUSTED
当我用CL_HTTP_CLIENT往一个外网的url发请求时,遇到错误:ICM_HTTP_SSL_PEER_CERT_UNTRUSTED 错误是从这段ABAP代码里抛出来的: CALL METHOD ...
- linux lnmp搭建
1.安装nginx: yum install gcc -y yum install -y pcre pcre-devel yum install -y zlib zlib-devel yum inst ...
- v-for的深层用法
为了提升循环的性能,我们会给循环加上一个唯一的key值,这个key值一定是唯一的 <div id='root'> <div v-for='(item,index) of list' ...
- Veritas NetBackup™ 状态码"十大"常见报错状态码
我在刚开始学习Netbackup的时候,没少走弯路.经常会遇到各种稀奇古怪的 error 信息,遇到报错会很慌张,急需一个解决问题的办法.跟无头苍蝇一样,会不加思索地把错误粘到百度上,希望赶紧查找一下 ...