初识 Python asyncio

最新推荐文章于 2023-08-31 20:16:36 发布

Idea King

最新推荐文章于 2023-08-31 20:16:36 发布

阅读量128

点赞数

分类专栏： python3 文章标签： asynchronous python

本文链接：https://blog.csdn.net/besmarterbestronger/article/details/108542644

版权

python3 专栏收录该内容

56 篇文章 3 订阅

订阅专栏

文章目录

1. 前言
- - 网络上的例子
  - 就好比拿水桶去接水。
2. 核心概念
3. 简单使用
- 协程与多线程/多进程相比有何优劣？
- 由于协程只使用1个线程，那岂不是浪费了多核CPU？
4. 参考文献

1. 前言

引用廖雪峰老师的话

由于我们要解决的问题是CPU高速执行能力和IO设备的龟速严重不匹配，多线程和多进程只是解决这一问题的一种方法。

另一种解决IO问题的方法是异步IO。当代码需要执行一个耗时的IO操作时，它只发出IO指令，并不等待IO结果，然后就去执行其他代码了。一段时间后，当IO返回结果时，再通知CPU进行处理。

这就是为什么需要异步IO。在一个线程中，在多个协程之间切换，充分实现CPU的高效使用。

先讲讲同步/异步和阻塞/非阻塞：建议看知乎怎样理解阻塞非阻塞与同步异步的区别？ YI LU的回答

同步和异步关注的是消息通信机制；阻塞和非阻塞关注的是程序在等待调用结果时的状态。

同步。就是在发出一个调用时，没得到结果之前，该调用就不返回。但是一旦调用返回就得到返回值了，调用者主动等待这个调用的结果
异步。就是在发出一个调用时，这个调用就直接返回了，不管返回有没有结果。当一个异步过程调用发出后，被调用者通过状态，通知来通知调用者，或者通过回调函数处理这个调用
-阻塞。调用结果返回之前，当前线程会被“挂起”，直到结果返回，才会恢复执行。
非阻塞。调用结果返回之前，当前线程可以去做其他事情，但是要时不时地检查是否有结果返回了。

网络上的例子

老张爱喝茶，废话不说，煮开水。
出场人物：老张，水壶两把（普通水壶，简称水壶；会响的水壶，简称响水壶）。
1 老张把水壶放到火上，立等水开。（同步阻塞）；立等就是阻塞了老张去干别的事，老张得一直主动的看着水开没，这就是同步

2 老张把水壶放到火上，去客厅看电视，时不时去厨房看看水开没有。（同步非阻塞）；老张去看电视了，这就是非阻塞了，但是老张还是得关注着水开没，这也就是同步了

3 老张把响水壶放到火上，立等水开。（异步阻塞）；立等就是阻塞了老张去干别的事，但是老张不用时刻关注水开没，因为水开了，响水壶会提醒他，这就是异步了

4 老张把响水壶放到火上，去客厅看电视，水壶响之前不再去看它了，响了再去拿壶。（异步非阻塞）；老张去看电视了，这就是非阻塞了，而且，等水开了，响水壶会提醒他，这就是异步

举个例子，看看之前的同步编程。

do_something()
f = open('test.txt')
result = f.read() # 线程停在此处，等待IO的结果，这段时间CPU啥事也没干，浪费了CPU资源
do_othner_something()
f.close()

而使用异步编程，就是当CPU空闲的时候，可以转而去做其他事情，这岂不美哉。

就好比拿水桶去接水。

同步编程：把桶放在水龙头下边，打开水龙头。这期间你就等着水接满，啥也不干。
异步编程：把桶放在水龙头下边，打开水龙头。不用等水接满，水满了自然会有动静告诉你已经满了，这期间你可以接第二桶水、第三桶水。

2. 核心概念

2.1 coroutine（协程）

协程，也叫做微线程。在一个线程之间，是一种用户态上下文切换技术，实现CPU的高效使用。在协程获得返回值之前可以暂停执行，将执行权转交给其他协程一段时间。

协程函数：用async def定义的函数。
协程对象：

协程的实现：

yield/yield from语法。
asyncio.coroutine装饰器。
async/await语法。推荐使用。
如下代码所示，定义了一个协程函数 main。

>>> import asyncio

>>> async def main():
...     print('hello')
...     await asyncio.sleep(1)
...     print('world')

>>> asyncio.run(main())
hello
world

当使用asycio.run(main())启动协程时，会发现打印hello之后隔1s会打印world。当然，现在看来这个同步的代码是一样（直接使用time.sleep(1)不也是一样的效果么？）。这是因为目前，没有多余的协程可以切换，所以看不出效果。

注意，当我们使用main()时，并没有执行协程。调用协程函数只是得到了一个协程对象（），单并不会执行这个协程对象。因此，要使用await关键字来执行awaitable（如，协程对象、Tasks、Futures等）

正确的协程函数定义

async def f(x):
    y = await z(x)  # OK - `await` and `return` allowed in coroutines
    return y

async def g(x):
    yield x  # OK - this is an async generator

async def m(x):
    yield from gen(x)  # No - SyntaxError，在async def 中，不能使用yield from

def m(x):
    y = await z(x)  # Still no - SyntaxError (no `async def` here)
    return y

2.2 awaitable（可等待对象）

能在 await表达式中使用的对象。可以是 coroutine 或是具有 __await__()方法的对象。
主要的awaitable对象：

协程对象
Tasks
Futures

2.3 Event loop（事件循环）

事件循环是每个 asyncio 应用的核心。事件循环会运行异步任务和回调，执行网络 IO 操作，以及运行子进程。

开发者通常应当使用高层级的 asyncio 函数，例如asyncio.run()，最好不要引用loop`对象或调用其方法。

await 关键字的意思是，当遇到await的 awaitable对象，表明需要等待awaitable执行完成之后，才能继续执行此协程的剩余部分。遇到await 表示需要中断当前协程的执行（例如，遇到耗时的IO操作，不能白白浪费CPU啊），转而去执行其他协程了。

2.4 Tasks

用来并发地调度协程。使用asyncio.create_task()可以将一个协程包装成一个Task，并自动将该协程的Task加入event loop中。

import asyncio
import time

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

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

    await say_after(1, 'hello')
    await say_after(2, 'world')

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

asyncio.run(main())

输出如下。用了3秒，并不是异步的。

started at 17:13:52
hello
world
finished at 17:13:55

现在我们把协程搞成Task。

async def main():
    task1 = asyncio.create_task(
        say_after(1, 'hello'))

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

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

    # Wait until both tasks are completed (should take
    # around 2 seconds.)
    await task1
    await task2

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

输出如下：用时2s，表明是异步的了。

started at 17:14:32
hello
world
finished at 17:14:34

创建一个Task

 # 第1种方式 ，推荐使用
 asyncio.create_task()
 # 第二种方式
 loop = asyncio.get_event_loop()
 loop.create_task()
 # 第三种方式
 asyncio.ensure_future()

2.5 Futures

一个 Future 是一个低级的awaitable对象，用来代表一个异步运算的最终结果。线程不安全。

Future 是一个 awaitable对象。协程可以等待Future对象直到它们有结果或异常或被取消。

3. 简单使用

#!/usr/bin/env python3
# countasync.py

import asyncio

async def count():
    print("One")
    await asyncio.sleep(1)
    print("Two")

async def main():
    await asyncio.gather(count(), count(), count())

if __name__ == "__main__":
    import time
    s = time.perf_counter()
    asyncio.run(main())
    elapsed = time.perf_counter() - s
    print(f"{__file__} executed in {elapsed:0.2f} seconds.")

输出结果如下：

$ python3 countasync.py
One
One
One
Two
Two
Two
countasync.py executed in 1.01 seconds.

从上面的输出顺序，我们也能发现其实异步执行的了。上面的代码，将3个count(）（其实是3个协程对象）加入了event loop。当第一个协程遇到await asyncio.sleep(1)时，会将执行权交还给event loop，让event loop 安排一个协程获取一段时间的执行权。

如果是同步编程：

#!/usr/bin/env python3
# countsync.py

import time

def count():
    print("One")
    time.sleep(1)
    print("Two")

def main():
    for _ in range(3):
        count()

if __name__ == "__main__":
    s = time.perf_counter()
    main()
    elapsed = time.perf_counter() - s
    print(f"{__file__} executed in {elapsed:0.2f} seconds.")

输出如下：

$ python3 countsync.py
One
Two
One
Two
One
Two
countsync.py executed in 3.01 seconds.

async def定义了一个协程函数。
await关键词将执行权交还给event loop。如下代码所示，在g()中遇到 await f()，那么会将执行权交还给event loop，让其安排其他协程执行，并将g()挂起，直到得到了f()的返回值。

async def g():
    # Pause here and come back to g() when f() is ready
    r = await f()
    return r

在Python 3.7以上的版本中，事件循环的整个管理由一个函数隐式处理（asyncio.run(main())）

Python 3.7中引入的asyncio.run()负责获取事件循环，运行任务直到将其标记为完成，然后关闭事件循环。

使用get_event_loop()，可以更轻松地管理asyncio事件循环。典型的模式如下所示：

loop = asyncio.get_event_loop()
try:
    loop.run_until_complete(main())
finally:
    loop.close()

在较早的示例中，您可能会看到loop.get_event_loop()随处可见，但是除非您特别需要微调对事件循环管理的控制，否则asyncio.run()对于大多数程序而言就足够了。

以下是事件循环的一些要点：

在将协程安排进事件循环之前，协程并不会做太多事情。
通过main()这种调用方式，只会得到一个协程对象，并不会真正的执行。

>>> import asyncio

>>> async def main():
...     print("Hello ...")
...     await asyncio.sleep(1)
...     print("World!")

>>> routine = main()
>>> routine
<coroutine object main at 0x1027a6150>

通过asyncio.run()在事件循环中调度main协程的执行。

>>> asyncio.run(routine)
Hello ...
World!

默认情况下，异步IO事件循环在单个线程和单个CPU内核上运行。通常，在一个CPU内核中运行一个单线程事件循环绰绰有余。还可以跨多个内核运行事件循环。
事件循环是可插拔的。 也就是说，如果您确实需要，可以编写自己的事件循环实现，并使它运行相同的任务。这在uvloop软件包中得到了很好的演示，该软件包是Cython中事件循环的实现。

协程与多线程/多进程相比有何优劣？

协程执行效率极高，没有线程切换，因此没有线程切换的开销。
通常，协程只在一个线程中的不同代码块进行切换，不需要多线程的锁机制，效率高。

由于协程只使用1个线程，那岂不是浪费了多核CPU？

可以使用多进程+协程。充分利用CPU资源。

4. 参考文献

[1] 这篇写的真的很不错 Python异步IO之协程(一):从yield from到async的使用
[2] Async IO in Python: A Complete Walkthrough
[3] 知乎怎样理解阻塞非阻塞与同步异步的区别？ YI LU的回答
[4] Python 官方文档 Asynchronous I/O
[5] 小破站 2小时学会python asyncio【花39大洋买的课程】
[6] 阮一峰的网络日志 Python 异步编程入门
[7] 廖雪峰的官方网站 asyncio

Idea King

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
初识 Python asyncio

文章目录1. 前言1. 前言引用廖雪峰老师的话由于我们要解决的问题是CPU高速执行能力和IO设备的龟速严重不匹配，多线程和多进程只是解决这一问题的一种方法。另一种解决IO问题的方法是异步IO。当代码需要执行一个耗时的IO操作时，它只发出IO指令，并不等待IO结果，然后就去执行其他代码了。一段时间后，当IO返回结果时，再通知CPU进行处理。await 关键字的意思是，当遇到await的 awaitable对象，表明需要等待awaitable执行完成之后，才能继续执行此协程的剩余部分。corou
复制链接

扫一扫