本文首发于知乎
异步是继多线程、多进程之后第三种实现并发的方式,主要用于IO密集型任务的运行效率提升。python中的异步基于yield生成器,在讲解这部分原理之前,我们先学会异步库asyncio的使用。
本文主要讲解asyncio模块的通用性问题,对一些函数细节的使用就简单略过。
本文分为如下部分
最简单的使用
另一种常见的使用方式
一个问题
一般函数下的异步
理解异步、协程
单个线程的的异步爬虫
最简单的使用
import asyncio
async def myfun(i):
print('start {}th'.format(i))
await asyncio.sleep(1)
print('finish {}th'.format(i))
loop = asyncio.get_event_loop()
myfun_list = (myfun(i) for i in range(10))
loop.run_until_complete(asyncio.gather(*myfun_list))
复制代码
这样运行,10次等待总共只等待了1秒。
上面代码一些约定俗成的用法记住就好,如
要想异步运行函数,需要在定义函数时前面加async
后三行都是记住就行,到时候把函数传入
另一种常见的使用方式
上面是第一种常见的用法,下面是另外一种
import asyncio
async def myfun(i):
print('start {}th'.format(i))
await asyncio.sleep(1)
print('finish {}th'.format(i))
loop = asyncio.get_event_loop()
myfun_list = [asyncio.ensure_future(myfun(i)) for i in range(10)]
loop.run_until_complete(asyncio.wait(myfun_list))
复制代码
这种用法和上面一种的不同在于后面调用的是asyncio.gather还是asyncio.wait,当前看成完全等价即可,所以平时使用用上面哪种都可以。
上面是最常看到的两种使用方式,这里列出来保证读者在看其他文章时不会发蒙。
另外,二者其实是有细微差别的
gather更擅长于将函数聚合在一起
wait更擅长筛选运行状况
细节可以参考这篇回答
一个问题
与之前学过的多线程、多进程相比,asyncio模块有一个非常大的不同:传入的函数不是随心所欲
比如我们把上面myfun函数中的sleep换成time.sleep(1),运行时则不是异步的,而是同步,共等待了10秒
如果我换一个myfun,比如换成下面这个使用request抓取网页的函数
import asyncio
import requests
from bs4 import BeautifulSoup
async def get_title(a):
url = 'https://movie.douban.com/top250?start={}&filter='.format(a*25)
r = requests.get(url)
soup = BeautifulSoup(r.content, 'html.parser')
lis = soup.find('ol', class_='grid_view').find_all('li')
for li in lis:
title = li.find('span', class_="title").text
print(title)
loop = asyncio.get_event_loop()
fun_list = (get_title(i) for i in range(10))
loop.run_until_complete(asyncio.gather(*fun_list))
复制代码
依然不会异步执行。
到这里我们就会想,是不是异步只对它自己定义的sleep(await asyncio.sleep(1))才能触发异步?
一般函数下的异步
对于上述函数,asyncio库只能通过添加线程的方式实现异步,下面我们实现time.sleep时的异步
import asyncio
import time
def myfun(i):
print('start {}th'.format(i))
time.sleep(1)
print('finish {}th'.format(i))
async def main():
loop = asyncio.get_event_loop()
futures = (
loop.run_in_executor(
None,
myfun,
i)
for i in range(10)
)
for result in await asyncio.gather(*futures):
pass
loop = asyncio.get_event_loop()
loop.run_until_complete(main())
复制代码
上面run_in_executor其实开启了新的线程,再协调各个线程。调用过程比较复杂,只要当模板一样套用即可。
上面10次循环仍然不是一次性打印出来的,而是像分批次一样打印出来的。这是因为开启的线程不够多,如果想要实现一次打印,可以开启10个线程,代码如下
import concurrent.futures as cf # 多加一个模块
import asyncio
import time
def myfun(i):
print('start {}th'.format(i))
time.sleep(1)
print('finish {}th'.format(i))
async def main():
with cf.ThreadPoolExecutor(max_workers = 10) as executor: # 设置10个线程
loop = asyncio.get_event_loop()
futures = (
loop.run_in_executor(
executor, # 按照10个线程来执行
myfun,
i)
for i in range(10)
)
for result in await asyncio.gather(*futures):
pass
loop = asyncio.get_event_loop()
loop.run_until_complete(main())
复制代码
用这种方法实现requests异步爬虫代码如下
import concurrent.futures as cf
import asyncio
import requests
from bs4 import BeautifulSoup
def get_title(i):
url = 'https://movie.douban.com/top250?start={}&filter='.format(i*25)
r = requests.get(url)
soup = BeautifulSoup(r.content, 'html.parser')
lis = soup.find('ol', class_='grid_view').find_all('li')
for li in lis:
title = li.find('span', class_="title").text
print(title)
async def main():
with cf.ThreadPoolExecutor(max_workers = 10) as executor:
loop = asyncio.get_event_loop()
futures = (
loop.run_in_executor(
executor,
get_title,
i)
for i in range(10)
)
for result in await asyncio.gather(*futures):
pass
loop = asyncio.get_event_loop()
loop.run_until_complete(main())
复制代码
这种开启多个线程的方式也算异步的一种,下面一节详细解释。
理解异步、协程
现在我们讲了一些异步的使用,是时候解释一些概念了
首先,我们要理清楚同步、异步、阻塞、非阻塞四个词语之间的联系
首先要明确,前两者后后两者并不是一一对应的,它们不是在说同一件事情,但是非常类似,容易搞混
一般我们说异步程序是非阻塞的,而同步既有阻塞也有非阻塞的
非阻塞是指一个任务没做完,没有必要停在那里等它结束就可以开始下一个任务,保证一直在干活没有等待;阻塞就相反是一件事完全结束才开始另一件事
在非阻塞的情况下,同步与异步都有可能,它们都可以在一个任务没结束就开启下一个任务。而二者的区别在于:(且称正在进行的程序为主程序)当第一个程序做完的时候(比如网络请求终于相应了),会自动通知主程序回来继续操作第一个任务的结果,这种是异步;而同步则是需要主程序不断去问第一个程序是否已经完成。
四个词的区别参考知乎回答
(协程与多线程的区别)在非阻塞的情况下,多线程是同步的代表,协程是异步的代表。二者都开启了多个线程
多线程中,多个线程会竞争谁先运行,一个等待结束也不会去通知主程序,这样没有章法的随机运行会造成一些资源浪费
而协程中,多个线程(称为微线程)的调用和等待都是通过明确代码组织的。协程就像目标明确地执行一个又一个任务,而多线程则有一些彷徨迷茫的时间
两种异步
前面几节涉及到两种异步,一种是await只使用一个线程就可以实现任务切换,另一种是开启了多个线程,通过线程调度实现异步
一般只用一个线程将任务在多个函数之间来回切换,是使用yield生成器实现的,例子可以看这篇文章最后生产消费者例子
多进程、多线程、异步擅长方向
异步和多线程都是在IO密集型任务上优势明显,因为它们的本质都是在尽量避免IO等待时间造成的资源浪费。而多进程可以利用多核优势,适合CPU密集型任务
相比于多线程,异步更适合每次等待时间较长、需要等待的任务较多的程序。因为多线程毕竟要创建新的线程,线程过多使线程竞争现象更加明显,资源浪费也就更多。如果每个任务等待时间过长,等待时间内势必开启了非常多任务,非常多线程,这时使用多线程就不是一个明智的决定。而异步则可以只开启一个线程在各个任务之间有条不紊进行,即能充分利用CPU资源,又不会影响程序运行效率
单个线程的的异步爬虫
上面我们是通过开启多个线程来实现requests的异步,如果我们想只用一个线程(用await),就要换一个网页请求函数。
事实上要想用await,必须是一个awaitable对象,这是不能使用requests的原因。而转化成awaitable对象这样的事当然也不用我们自己实现,现在有一个aiohttp模块可以将网页请求和asyncio模块完美对接。使用这个模块改写代码如下
import asyncio
import aiohttp
from bs4 import BeautifulSoup
async def get_title(i):
url = 'https://movie.douban.com/top250?start={}&filter='.format(i*25)
async with aiohttp.ClientSession() as session:
async with session.get(url) as resp:
print(resp.status)
text = await resp.text()
print('start', i)
soup = BeautifulSoup(text, 'html.parser')
lis = soup.find('ol', class_='grid_view').find_all('li')
for li in lis:
title = li.find('span', class_="title").text
print(title)
loop = asyncio.get_event_loop()
fun_list = (get_title(i) for i in range(10))
loop.run_until_complete(asyncio.gather(*fun_list))
复制代码
欢迎关注我的知乎专栏
专栏目录:目录