python异步模块_python异步asyncio模块的使用

本文首发于知乎

异步是继多线程、多进程之后第三种实现并发的方式,主要用于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))

复制代码

欢迎关注我的知乎专栏

专栏目录:目录

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值