python异步编程asyncio

前提概要：python因为GIL锁，所以运行都是单线程，导致python运行的速度慢，为此要解决这个问题有多进程、多线程，但是使用这些方法，我们就要多加考虑线程安全问题，顾很麻烦，所以推出了协程。协程运行在线程上，所以一样是单线程，但是却能实现并发，遇见io耗时操作a，会把这个a操作挂后台执行，程序接着执行下一个操作b，当后台操作a结束后，程序再回去解决操作a的返回结果。类似前端js的编程思想。当然了解决这个python并发问题还有celery等等很多方法。

写这篇的目的：因为曾经写爬虫使用过asyncio，后来后端变成使用go，所以最近感觉有点遗忘这个语法，因此写下一篇记录一下（参考文档：asyncio --- 异步 I/O — Python 3.10.2 文档）

一、基本使用

（1）基础语法

能使用await必须是可等待对象：协程、任务、Future.

协程：带有async的函数是协程函数，可等待

任务：用asyncio.create_task()方法创建的任务

Future：是一种特殊的 低层级 可等待对象，表示一个异步操作的 最终结果。当一个 Future 对象 被等待，这意味着协程将保持等待直到该 Future 对象在其他地方操作完毕。在 asyncio 中需要 Future 对象以便允许通过 async/await 使用基于回调的代码。通常情况下 没有必要 在应用层级的代码中创建 Future 对象。Future 对象有时会由库和某些 asyncio API 暴露给用户，用作可等待对象。

import asyncio
import time

async def say_after(delay, what):
    await asyncio.sleep(delay)
    print(what)

async def main():

    # 创建任务 task1、task2
    task1 = asyncio.create_task(
        say_after(1, 'hello'))

    task2 = asyncio.create_task(
        say_after(2, 'world'))

    print(f"started at {time.strftime('%X')}")

    # 执行这两个任务
    await task1
    await task2

    print(f"finished at {time.strftime('%X')}")

# 不能普通的调用main(),否则就不是协程操作
asyncio.run(main())

"""
运行结果：

started at 09:36:34
hello
world
finished at 09:36:36

"""

（2）任务执行的结果，存入并返回一个列表

import asyncio

async def factorial(name, number):
    f = 1
    for i in range(2, number + 1):
        print(f"Task {name}: Compute factorial({number}), currently i={i}...")
        await asyncio.sleep(1)
        f *= i
    print(f"Task {name}: factorial({number}) = {f}")
    return f

async def main():
    # 异步执行，这3个任务:
    L = await asyncio.gather(
        factorial("A", 2),
        factorial("B", 3),
        factorial("C", 4),
    )
    print(L)

asyncio.run(main())

"""

执行结果：放在一块的，是并发执行出来的结果

Task A: Compute factorial(2), currently i=2...
Task B: Compute factorial(3), currently i=2...
Task C: Compute factorial(4), currently i=2...

Task A: factorial(2) = 2
Task B: Compute factorial(3), currently i=3...
Task C: Compute factorial(4), currently i=3...

Task B: factorial(3) = 6
Task C: Compute factorial(4), currently i=4...

Task C: factorial(4) = 24
[2, 6, 24]


"""

（3）超时：

        （3.1）wait_for()--->超时会被取消

import asyncio

async def eternity():
    # 休眠1个小时
    await asyncio.sleep(3600)
    print('yay!')

async def main():
    # 超时需要使用异常来抓取
    try:
        await asyncio.wait_for(eternity(), timeout=1.0)
    except asyncio.TimeoutError:
        print('timeout!')

asyncio.run(main())

# 执行结果:
#
#     timeout!

（4）在线程上运行协程：在任何协程中直接调用 blocking_io() 将会在调用期间阻塞事件循环，导致额外的 1 秒运行时间。 而通过改用 asyncio.to_thread()，我们可以在不同的线程中运行它从而不会阻塞事件循环。

asyncio.to_thread(func, /, *args, **kwargs)：在不同的线程中异步地运行函数 func

import asyncio
import asyncio, time

def blocking_io():
    print(f"start blocking_io at {time.strftime('%X')}")
    time.sleep(1)
    print(f"blocking_io complete at {time.strftime('%X')}")

async def main():
    print(f"started main at {time.strftime('%X')}")

    await asyncio.gather(
        asyncio.to_thread(blocking_io),
        asyncio.sleep(1))

    # 如果有更多的任务，可以用list解包的方式放入值
    # await asyncio.gather(*[tasks])

    print(f"finished main at {time.strftime('%X')}")


asyncio.run(main())

"""

运行结果：

started main at 10:33:33
start blocking_io at 10:33:33

blocking_io complete at 10:33:34
finished main at 10:33:34

"""

（5）task对象（任务对象）：常用方法，使用高层级的asyncio.create_task() 函数来创建 Task 对象，也可用低层级的 loop.create_task() 或 ensure_future() 函数。不建议手动实例化 Task 对象。

1. task.cancel(): 取消任务

2. task.cancelled(): 如果task被取消，返回True

3. task,done(): 如果task已完成返回True

4. task.result(): 返回task执行的结果

5. task.exception(): 返回task异常

6. task.add_done_callback(callback, *, context=None): task执行结束后增加的回调

7. task.get_coro()：返回由 task 包装的协程对象

8. task.get_name()：返回 Task 的名称

9. task.set_name(value)：设置 Task 的名称。

二、曾经遇见的一个面试题

题目描述：用协程的方式，打印出时间，要求体现并发效果

import asyncio
import time

async def job1():
    await asyncio.sleep(1)
    print("job1执行结束")

async def job2():
    await asyncio.sleep(3)
    print("job2执行结束")

async def main():
    print(f"{time.strftime('%X')}")
    await asyncio.gather(*[job1(), job2()])
    print(f"{time.strftime('%X')}")

"""
这样写也行，task对象可以有更多操作

async def main():
    task1 = asyncio.create_task(job1())
    task2 = asyncio.create_task(job2())
    
    print(f"{time.strftime('%X')}")
    await asyncio.gather(*[task1,task2])
    print(f"{time.strftime('%X')}")


"""



asyncio.run(main())


"""

执行结果：

11:11:33
job1执行结束
job2执行结束
11:11:36

"""