协程
协程(Coroutine),也可以被称为微线程,是一种用户态内的上下文切换技术。简而言之,其实就是通过一个线程实现代码块相互切换执行
在Python中有多种方式可以实现协程,例如:
- greenlet,是一个第三方模块,用于实现协程代码(Gevent协程就是基于greenlet实现)
- yield,生成器,借助生成器的特点也可以实现协程代码。
- asyncio,在Python3.4中引入的模块用于编写协程代码。
- async & awiat,在Python3.5中引入的两个关键字,结合asyncio模块可以更方便的编写协程代码。【推荐】
异步编程
异步编程的两大核心: 事件循环 + 协程函数
1.事件循环(可理解为死循环)
循环检查并执行一些任务
,在特定条件下终止循环,这些任务会有三种运行状态: 待执行,正在执行,IO状态
# 伪代码
任务列表 = [ 任务1, 任务2, 任务3,... ]
while True:
可执行的任务列表,已完成的任务列表 = 去任务列表中检查所有的任务,将'可执行'和'已完成'的任务返回
for 就绪任务 in 已准备就绪的任务列表:
执行已就绪的任务
for 已完成的任务 in 已完成的任务列表:
在任务列表中移除 已完成的任务
如果 任务列表 中的任务都已完成,则终止循环
asyncio 生成或获取事件循环
import asyncio
# 生成或获取事件循环对象loop
loop = asyncio.get_event_loop()
# 将协程函数(任务)提交到事件循环的任务列表中,协程函数执行完成之后终止。
# run_until_complete 会检查协程函数的运行状态,并执行协程函数
loop.run_until_complete( func() )
注意: python3.7+ 后的写法:
asyncio.run( func() ) # run方法内部封装了 get_event_loop() 与 run_until_complete()
2.协程函数
定义协程函数 :async def 关键字 (python3.5+)
协程对象:协程函数运行的结果即为协程对象
async def func1():
pass
f = func() # 协程函数运行生成协程函数对象
注意: 协程函数加括号不会执行协程函数内部代码,只是得到一个协程对象
案例:
如果要运行协程函数内容代码,必须将协程函数交给asyncio事件循环来执行
import asyncio
async def func():
print(1)
f = func()
loop = asyncio.get_event_loop()
loop.run_until_complete( f )
await
用法:reponse = await + 可等待对象
- 可等待对象: 协程对象, Future, Task对象 可理解为IO等待
- response : 等待的结果
- await 遇到IO操作会挂起当前协程(任务),当前协程挂起时,事件循环可以去执行其他协程(任务)
注意:可等待对象若是协程对象则变成串行,若是Task对象则并发运行
import asyncio
async def func():
print(1)
response = await asyncio.sleep(2) # asyncio.sleep 模仿IO操作
# 若 await 等待的是下载图片,那么 response 的值是下载的图片
print('协程函数运行结束', response)
loop = asyncio.get_event_loop()
loop.run_until_complete( func() )
案例:
import asyncio
async def others():
print("start")
await asyncio.sleep(2)
print('end')
return '返回值'
async def func():
print("执行协程函数内部代码")
# 遇到IO操作挂起当前协程(任务),等IO操作完成之后再继续往下执行。当前协程挂起时,事件循环可以去执行其他协程(任务)。
response1 = await others()
print("IO请求结束,结果为:", response1)
response2 = await others()
print("IO请求结束,结果为:", response2)
# await 后面的可等待对象为 协程对象, 所有运行方式为串行
loop = asyncio.get_event_loop()
loop.run_until_complete( func() )
>>>>>>>:
执行协程函数内部代码
start
end
IO请求结束,结果为: 返回值
start
end
IO请求结束,结果为: 返回值
注意: await 会等待 '可等待对象' 运行结束后,再继续向下执行代码
协程函数 + await + 协程对象 + await + 协程对象 ....... 可看做是一条线,当遇到IO时,循环事件列表中若有其他线,则运行其他线,若无其他线,则等待IO结束后再继续运行
Task对象
作用:在事件循环列表中添加多个任务
Tasks用于并发调度协程,通过asyncio.create_task(协程对象)
的方式创建Task对象,这样可以让协程加入事件循环中等待被调度执行。除了使用 asyncio.create_task()
函数以外,还可以用低层级的 loop.create_task()
或 ensure_future()
函数。不建议手动实例化 Task 对象。
本质上是将协程对象封装成task对象,并将协程立即加入事件循环,同时追踪协程的状态。
注意:asyncio.create_task()
函数在 Python 3.7 中被加入。在 Python 3.7 之前,可以改用低层级的 asyncio.ensure_future()
函数。
import asyncio
async def func():
print(1)
await asyncio.sleep(2)
print(2)
return "返回值"
async def main():
print("main开始")
# 创建协程,将协程封装到一个Task对象中并立即添加到事件循环的任务列表中,等待事件循环去执行(默认是就绪状态)。
task1 = asyncio.ensure_future(func())
# 创建协程,将协程封装到一个Task对象中并立即添加到事件循环的任务列表中,等待事件循环去执行(默认是就绪状态)。
task2 = asyncio.ensure_future(func())
# 此时,事件循环列表中有三个任务 [main(), func(), func()]
print("main运行中")
# 当执行某协程遇到IO操作时,会自动化切换执行其他任务。
# 此处的await是等待相对应的协程全都执行完毕并获取结果, task1 与 task2 并发运行
ret1 = await task1
ret2 = await task2
# 协程函数main() 等待 task1 和 task2 运行结束后再运行
print(ret1, ret2)
print("main结束")
loop = asyncio.get_event_loop()
loop.run_until_complete(main())
>>>>>>:
main开始
main运行中
1
1
2
2
返回值 返回值
main结束
常规写法1:
import asyncio
async def func():
print(1)
await asyncio.sleep(2)
print(2)
return "返回值"
async def main():
print("main开始")
task_list = [
asyncio.ensure_future(func()),
asyncio.ensure_future(func())
]
print("main运行中")
done,pending = await asyncio.wait(
task_list,
timeout=None # timeout 等待时间,若等待时间内协程函数没有执行完,则放入pending中, None表示等待协程函数运行结束
)
print(done)
print(pending)
print("main结束")
loop = asyncio.get_event_loop()
loop.run_until_complete(main())
常规写法2:
import asyncio
async def func():
print("执行协程函数内部代码")
# 遇到IO操作挂起当前协程(任务),等IO操作完成之后再继续往下执行。当前协程挂起时,事件循环可以去执行其他协程(任务)。
response = await asyncio.sleep(2)
print("IO请求结束,结果为:", response)
coroutine_list = [
func(),
func()
]
# 错误:coroutine_list = [ asyncio.create_task(func()), asyncio.create_task(func()) ]
# 此处不能直接 asyncio.create_task,因为将Task立即加入到事件循环的任务列表,
# 但此时事件循环还未创建,所以会报错。
# 使用asyncio.wait将列表封装为一个协程,并调用loop.run_until_complete实现执行两个协程
# asyncio.wait内部会对列表中的每个协程执行ensure_future,封装为Task对象。
loop = asyncio.get_event_loop()
done,pending = loop.run_until_complete( asyncio.wait(coroutine_list) )
asycio.Future对象
import asyncio
async def func():
print(3)
await asyncio.sleep(2)
print(4)
async def main():
print(1)
# 获取当前事件循环
loop = asyncio._get_running_loop()
# 创建一个任务(Future对象),这个任务什么都不干。
fut = loop.create_future()
# 等待任务最终结果(Future对象),没有结果则会一直等下去。
await fut
print(2)
loop = asyncio.get_event_loop()
loop.run_until_complete(main())
asycio + 进程池/线程池的异步
在开发过程中会遇到一些模块不支持异步操作,这是就要用到 asycio + 线程池/进程池
run_in_executor() 方法可以将不支持异步操作的方法变为 asycio.Future 对象,从而和 asyncio 配合使用
run_in_executor()内部就是使用的线程池
import time
import asyncio
import concurrent.futures
def func1():
# 某个耗时操作
time.sleep(2)
return "SB"
async def main():
loop = asyncio._get_running_loop()
# 1. Run in the default loop's executor ( 默认ThreadPoolExecutor )
# 第一步:内部会先调用 ThreadPoolExecutor 的 submit 方法去线程池中申请一个线程去执行func1函数,并返回一个concurrent.futures.Future对象
# 第二步:调用asyncio.wrap_future将concurrent.futures.Future对象包装为asycio.Future对象。
# 因为concurrent.futures.Future对象不支持await语法,所以需要包装为 asycio.Future对象 才能使用。
fut = loop.run_in_executor(None, func1) # run_in_executor 返回的是 asycio.Future对象
result = await fut
print('default thread pool', result)
# # 2. Run in a custom thread pool:
# with concurrent.futures.ThreadPoolExecutor() as pool:
# result = await loop.run_in_executor(
# pool, func1)
# print('custom thread pool', result)
# # 3. Run in a custom process pool:
# with concurrent.futures.ProcessPoolExecutor() as pool:
# result = await loop.run_in_executor(
# pool, func1)
# print('custom process pool', result)
asyncio.run(main())
案例:
import asyncio
import requests
async def download_image(url):
# 发送网络请求,下载图片(遇到网络下载图片的IO请求,自动化切换到其他任务)
print("开始下载:", url)
# loop = asyncio._get_running_loop()
loop = asyncio.get_event_loop()
# requests模块默认不支持异步操作,所以就使用线程池来配合实现了。
future = loop.run_in_executor(None, requests.get, url)
response = await future
print('下载完成')
# 图片保存到本地文件
file_name = url.rsplit('_')[-1]
with open(file_name, mode='wb') as file_object:
file_object.write(response.content)
if __name__ == '__main__':
url_list = [
'https://www3.autoimg.cn/newsdfs/g26/M02/35/A9/120x90_0_autohomecar__ChsEe12AXQ6AOOH_AAFocMs8nzU621.jpg',
'https://www2.autoimg.cn/newsdfs/g30/M01/3C/E2/120x90_0_autohomecar__ChcCSV2BBICAUntfAADjJFd6800429.jpg',
'https://www3.autoimg.cn/newsdfs/g26/M0B/3C/65/120x90_0_autohomecar__ChcCP12BFCmAIO83AAGq7vK0sGY193.jpg'
]
tasks = [download_image(url) for url in url_list]
loop = asyncio.get_event_loop()
loop.run_until_complete( asyncio.wait(tasks) )
异步迭代器
异步迭代器:
实现了 __aiter__() 和 __anext__() 方法的对象。__anext__
必须返回一个 awaitable 对象。async for 会处理异步迭代器的 __anext__() 方法所返回的可等待对象,直到其引发一个 StopAsyncIteration 异常
异步可迭代对象:
可在 async for 语句中被使用的对象。必须通过它的 __aiter__() 方法返回一个 asynchronous iterator 异步迭代器
自定义异步迭代器:
import asyncio
class Reader(object):
""" 自定义异步迭代器(同时也是异步可迭代对象) """
def __init__(self, n):
self.count = 0
self.n = n
async def readline(self):
# await asyncio.sleep(1)
self.count += 1
if self.count == self.n:
return None
return self.count
def __aiter__(self):
return self
async def __anext__(self):
val = await self.readline()
if val == None:
raise StopAsyncIteration
return val
async def func(n):
# 创建异步可迭代对象
async_iter = Reader(n)
# async for 必须要放在async def函数内,否则语法错误。
async for item in async_iter:
print(item)
loop = asyncio.get_event_loop()
loop.run_until_complete(func(5))
# asyncio.run(func())
异步上下文管理器
对象通过定义 __aenter__() 和 __aexit__() 方法来对 async with 语句中的环境进行控制
开发过程中 打开、处理、关闭 操作时,就可以用这种方式来处理
自定义异步上文管理器:
import asyncio
class AsyncContextManager:
def __init__(self):
self.conn = 0
async def do_something(self):
# 异步操作数据库
return 666
async def __aenter__(self):
# 异步链接数据库
self.conn = await asyncio.sleep(1)
return self
async def __aexit__(self, exc_type, exc, tb):
# 异步关闭数据库链接
await asyncio.sleep(1)
async def func():
async with AsyncContextManager() as f:
result = await f.do_something()
print(result)
loop = asyncio.get_event_loop()
loop.run_until_complete(func())
# asyncio.run(func())
asyncio
import asyncio
@asyncio.coroutine
def func1():
print(1)
yield from asyncio.sleep(2) # 遇到IO耗时操作,自动化切换到tasks中的其他任务
# 此处的 yield from 作用 :1.挂起函数,2.去运行 asyncio.sleep(2)来模仿IO操作
# 模仿实际项目中的IO操作,如网络IO请求,读写磁盘IO请求
print(2)
@asyncio.coroutine
def func2():
print(3)
yield from asyncio.sleep(2) # 遇到IO耗时操作,自动化切换到tasks中的其他任务
print(4)
# loop = asyncio.get_event_loop() # 创建事件循环
# loop.run_until_complete(func1()) # 执行 协程函数
'''
被 @asyncio.coroutine 装饰的函数为协程函数
协程函数不能单独运行,如 func1()无法运行,需要通过 创建事件循环 来执行 携程函数
'''
tasks = [
asyncio.ensure_future( func1() ),
asyncio.ensure_future( func2() )
]
loop = asyncio.get_event_loop() # 创建事件循环
loop.run_until_complete(asyncio.wait(tasks)) # python随机执行tasks任务列表中注册的协程函数
async & awiat
async & awit 关键字代替了 @asyncio.coroutine 和 yield from
awit:挂起协程函数,等待IO任务完成后继续执行
import asyncio
async def func1():
print(1)
await asyncio.sleep(2)
print(2)
async def func2():
print(3)
await asyncio.sleep(2)
print(4)
tasks = [
asyncio.ensure_future(func1()),
asyncio.ensure_future(func2())
]
loop = asyncio.get_event_loop()
loop.run_until_complete(asyncio.wait(tasks))
问题:RuntimeError: There is no current event loop in thread 'ThreadPoolExecutor-0_0