当前位置: article > 正文

python 异步编程 asyncio_asyncio.run

作者：知新_RL | 2024-02-13 12:49:50

踩

asyncio.run

协程

协程（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

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/知新_RL/article/detail/79988