异步编程

1.1 事件循环

理解成为一个死循环. 去检测病执行某些代码

# 伪代码
任务列表 = [ 任务1, 任务2, 任务3,...]

while True:
   可执行的任务列表,已完成的任务列表 = 去任务列表中检查所有的任务, 并将'可执行' 和 '已完成'的任务返回
   for 就绪任务 in 可执行的任务列表:
   	执行已就绪的任务
   
   for 已完成的额任务 in 已完成的任务列表:
   	在任务列表中移除 已完成的任务
   如果 任务列表 中的 任务都已完成 则终止循环

import asyncio


# 去生成获取一个事件循环
loop = asyncio.get_event_loop()

# 将任务放到`任务队列`
loop.run_until_complete(tasks)

1.2 快速上手 async

协程函数,定义函数时候 async def 函数名.
协程对象,执行 协程函数() 得到的协程对象

# todo 执行协程函数创建写成对象,函数内部代码不会执行.

async def func():
	pass
result  = func()

执行协程函数创建写成对象,函数内部代码不会执行.
如果想要运行写成函数内部代码,必须要将写成对象交给事件循环来处理.

import asyncio

async def func():
	print("搞我  马上")
result  = func()

loop = asyncio.get_event_loop()
loop.run_until_complete(result)

# | asyncio.run(result) # python3.7+

1.3 await

await + 可等待的对象(协程对象|Future|Task对象 -IO等待)
示例一

import asyncio


async def func():
	print("来玩啊")
	response = await asyncio.sleep(2)
	print("结束")

asyncio.run( func() )

示例二

import asyncio


async def others():
    print('start')
    await asyncio.sleep(2)
    print('end')
    return 'result'


async def func():
    print('执行协程函数内部代码')
    # 遇到io操作挂起当前协程(任务),等io操作完成之后在继续往下执行，当前协程挂其实，事件循环可以去执行其他协程（任务）。
    response = await others()
    print("IO请求结束，结果为:", response)


asyncio.run(func())

示例三

import asyncio


async def others():
    print('start')
    await asyncio.sleep(2)
    print('end')
    return 'result'


async def func():
    print('执行协程函数内部代码')
    # 遇到io操作挂起当前协程(任务),等io操作完成之后在继续往下执行，当前协程挂其实，事件循环可以去执行其他协程（任务）。
    response1 = await others()
    print("IO1请求结束，结果为:", response1)
    
    response2 = await others()
    print("IO2请求结束，结果为:", response2)


asyncio.run(func())

await就是等待对象的值 得到结果之后再继续向下走

1.4 Task对象

在事件循环中添加多个任务

Tasks用于并发调度协程,通过asyncio.create_task(协程对象)的方式创建Task对象,这样可以让写成加入事件循环中等待被调度执行.除了使用asyncio.create_task()函数以外,还可以用低层级的loop.create_task() 或者 ensure_future()函数.不建议手动实例化Task对象.

注意:asyncio.create_task() 函数在python3.7中被加入,在python3.7之前,可以改用低层级的asyucio.ensure_future()函数.

示例一:

import asyncio


async def func():
    print(1)
    await asyncio.sleep(2)
    print(2)
    return 'result'


async def main():
    print("main 开始了")
    # 创建Task对象，将当前执行func函数任务添加到事件循环。
    task1 = asyncio.create_task(func())

    # 创建Task对象，将当前执行func函数任务添加到事件循环。
    task2 = asyncio.create_task(func())
    print("main 结束")

    # 当执行某协程遇到IO操作时，会自动化切换执行其他任务。。
    # 此处的await时等待想对应的协程全都执行完毕并获取结果
    ret = await task1
    ret2 = await task2
    print(ret, ret2)


asyncio.run( main() )

示例二

import asyncio


async def func():
    print(1)
    await asyncio.sleep(2)
    print(2)
    return 'result'


async def main():
    print("main 开始了")
    task_list = [
        asyncio.create_task(func()),
        asyncio.create_task(func())
    ]
    print("main 结束")
    # done 就是任务的返回值 pending -> timeout 最多等待两秒 默认None
    done, pending = await asyncio.wait(task_list, timeout=None)
    print(done)


asyncio.run(main())

示例三

import asyncio


async def func():
    print(1)
    await asyncio.sleep(2)
    print(2)
    return 'result'


print("main 开始了")
task_list = [
    func(),
    func()
]
print("main 结束")
# done 就是任务的返回值 pending -> timeout 最多等待两秒 默认None
done, pending = asyncio.run(asyncio.wait(task_list))
print(done)

1.5 asyncio.Futrue对象

更偏向底层 Task的基类

Task继承Future Task对象内部await结果的处理基于Future对象来的

示例一

import asyncio


async def main():
    # 获取当前事件循环
    loop = asyncio.get_running_loop()

    # 创建一个任务(Feture对象)，这个任务什么都不干
    fut = loop.create_future()

    # 等待任务最终结果(Feture对象) 没有结果则会一直等下去
    await fut


asyncio.run(main())

示例二

 import asyncio


async def set_after(fut):
    await asyncio.sleep(2)
    fut.set_result('666')


async def main():
    # 获取当前事件循环
    loop = asyncio.get_running_loop()

    # 创建一个任务（Future对象），没绑定任何行为，则这个任务永远不知道什么时候结束。
    fut = loop.create_future()

    # 创建一个任务（Task对象），绑定了set_after函数，函数内部在2s之后会给fut赋值
    # 即手动设置future任务的最终结果，那么fut就可以结束了。
    await loop.create_task(set_after(fut))

    # 等待Future对象获取 最终结果，否则一直等下去
    data = await fut
    print(data)


asyncio.run(main())

1.6 concurrent.futrue.Future 对象

concurrent.futrue.Future使用线程池 进程吃实现异步操作时用到的对象.

import time
from concurrent.futures import Future
from concurrent.futures.thread import ThreadPoolExecutor
from concurrent.futures.process import ProcessPoolExecutor


def func(value):
    time.sleep(1)
    print(value)


# 创建一个线程池
pool = ThreadPoolExecutor(max_workers=5)

# todo 创建一个进程池 
# pool = ProcessPoolExecutor(max_workers=5)

for i in range(10):
    fut = pool.submit(func, i)
    print(fut)

以后写代码可能会存在交叉使用例如:crm项目80%都是基于协程异步编程 + Mysql (不支持)

解决 基于线程 进程做异步编程

1.7 案例: asyncio + 不支持异步的模块

import asyncio
import requests


async def download_url(url):
    # 发送网络请求，下载图片 ( 遇到网络下载图片的IO请求，自动化切换到其他任务)
    print("开始下载:%s" % url)
    loop = asyncio.get_event_loop()

    # requests模块默认不支持异步操作，所以就使用线程池来配合实现。
    future = loop.run_in_executor(None, requests.get, url)
    response = await future
    print("下载完成")
    file_name = url.split("/")[-1]
    with open(file_name, 'wb') as file_object:
        file_object.write(response.content)


if __name__ == '__main__':
    url_list = [
        "http://img.netbian.com/file/2022/0223/001345XOhx0.jpg",
        "https://pic.netbian.com/uploads/allimg/220208/200740-16443220602c60.jpg",
        "https://pic.netbian.com/uploads/allimg/220202/234059-164381645989ad.jpg"
    ]
    tasks = [download_url(url) for url in url_list]
    loop = asyncio.get_event_loop()
    loop.run_until_complete(asyncio.wait(tasks))

1.8 异步迭代器

实现了__aiter__() 和 __anext__() 方法的对象。__anext__必须返回一个awaitable对象。 async_for 会处理异步迭代器的__anext__()方法锁返回的可等待对象，知道其引发一个StopAsyncIteration异常、由PEP 492 引入

什么是异步可迭代对象?

可在async_for语句中被使用的对象。必须通过它的__aiter__()方法返回一个asynchronous_iterator 由PEP 429引入。

 import asyncio


class Reader(object):
    """ 自定义异步迭代器(同时也是异步可迭代对象) """

    def __init__(self):
        self.count = 0

    async def readline(self):
        # await asyncio.sleep(1)
        self.count += 1
        if self.count == 100:
            return
        return self.count

    def __aiter__(self):
        return self

    async def __anext__(self):
        val = await self.readline()
        if not val:
            raise StopAsyncIteration
        return val


async def func():
    obj = Reader()
    async for item in obj:
        print(item)
asyncio.run(func())

1.9 异步上下文管理器

此种对象通过定义__aenter__() 和__aexit__()方法来对async_with语句中的环境进行控制.由EPE 492引入。

import asyncio


class AsyncContextManager:
    def __init__(self, conn):
        self.conn = conn

    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)


asyncio.run(func())