Python学习笔记：协程初探

布满荆棘的人生 2023-06-25 13:28 138阅读 0赞

（本文主要参照Python在线文档进行学习）

# 0.前言 #

进程有自己独立的堆和栈，由操作系统调度；线程有独立的栈，共享堆空间，标准的线程也是由操作系统调度；协程和线程一样共享堆不共享栈，但是是由程序员在协程的代码里显示调度。协程避免了无意义的调度，进而提升性能，但也增加了程序员的责任。

# 1.初探 #

asyncio是一个使用 async / await 语法编写并发代码的库，在Python 3.4 引入，直接内置了对异步IO的支持，并在后来的版本中不断完善。早期基于生成器来实现协程，但是在 Python 3.8 开始不推荐使用该方式，并将在 3.10 移除。目前标准的是使用 async / await 语法来实现协程。

要实际运行协程，asyncio 提供了三种主要机制：

**a.使用 asyncio.run() 函数来运行顶层入口点**

（运行代码需要 Python3.7 ；要注意的是，直接调用 func() 并不能执行）

import asyncio
    import time
    
    async def func():
        print('func in'+time.strftime('%X'))
        await asyncio.sleep(3)
        print('func out'+time.strftime('%X'))
    
    print('begin'+time.strftime('%X'))
    asyncio.run(func())
    print('end'+time.strftime('%X'))

![20191229135548559.png][]

**b.等待协程**

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())

![20191229135217592.png][]

**c.用asyncio.create\_task() 函数把协程作为异步任务来同时执行**

（修改上个示例的 main 函数）

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')}")

![20191229135306788.png][]

# 2.可等待的对象 awaitable #

如果可以在 await 表达式中使用，则这个对象是 awaitable 的。可等待的对象主要有三种：协程coroutines，任务Tasks，期望Futures。

**a.协程coroutines**

Python 协程是可等待的，并且可以等待自其他协程：

import asyncio
    
    async def nested():
        return 42
    
    async def main():
        # 一个协程对象创建了但是没有被等待，不会执行
        print(nested())
        # 输出 "42".
        print(await nested())  
    
    asyncio.run(main())

![20191229140829873.png][]

协程相关的两个重要概念：协程函数，通过 async def 定义的函数；协程对象，调用协程函数返回的对象。

**b.任务Tasks**

任务可以用来调度协程并发执行。当使用 asyncio.create\_task() 打包一个协程，该协程很快会自动计划运行。

import asyncio
    
    async def nested():
        return 42
    
    async def main():
        # nested() 与 main() 会同时运行
        task = asyncio.create_task(nested())
        # "task" 现在可用于取消 "nested()", 或是等待其完成
        await task
    
    asyncio.run(main())

**c.期望Futures**

Futures 是特殊的低级可等待对象，代表异步操作的最终结果。当 await 一个 Futures 时，协程将等待直到 Futures 在别的地方完成。一般不需要在应用中创建 Futures 对象。

# 3.部分API参考 #

**a.运行一个异步程序**

asyncio.run(coro, *, debug = False )

执行协程 coro 并返回结果。它应该用作 asyncio 程序的主要入口点，理想情况下应该只调用一次。

**b.创建任务**

asyncio.create_task(coro, *, name = None )

将协程 coro 包装为一个 Task 并调度执行，返回一个 Task 对象。

**c.休眠**

asyncio.sleep(delay, result=None, *, loop=None)

阻塞等待 delay 秒，sleep 挂起当前任务，允许其他任务运行。

**d.同时运行**

asyncio.gather(*aws, loop=None, return_exceptions=False)

并发执行 aws 列表中的可等待对象。如果 aws 中有任何可等待的协程，将自动作为一个 Task 调度。

import asyncio
    
    async def factorial(name, number):
        f = 1
        for i in range(2, number + 1):
            print(f"Task {name}: Compute factorial({i})...")
            await asyncio.sleep(1)
            f *= i
        print(f"Task {name}: factorial({number}) = {f}")
    
    async def main():
        # Schedule three calls *concurrently*:
        await asyncio.gather(
            factorial("A", 2),
            factorial("B", 3),
            factorial("C", 4),
        )
    
    asyncio.run(main())
    
    # Expected output:
    #
    #     Task A: Compute factorial(2)...
    #     Task B: Compute factorial(2)...
    #     Task C: Compute factorial(2)...
    #     Task A: factorial(2) = 2
    #     Task B: Compute factorial(3)...
    #     Task C: Compute factorial(3)...
    #     Task B: factorial(3) = 6
    #     Task C: Compute factorial(4)...
    #     Task C: factorial(4) = 24

**e.超时等待**

asyncio.wait_for(aw, timeout, *, loop=None)

aw 是一个协程，如果 timeout 秒数为 None，将会阻塞直到完成。

async def eternity():
        # Sleep for one hour
        await asyncio.sleep(3600)
        print('yay!')
    
    async def main():
        # Wait for at most 1 second
        try:
            await asyncio.wait_for(eternity(), timeout=1.0)
        except asyncio.TimeoutError:
            print('timeout!')
    
    asyncio.run(main())
    
    # Expected output:
    #
    #     timeout!

协程相关的接口还是挺多的，这里只列举了部分，详情可以参照书籍或文档

# 4.参考： #

Python在线文档：[https://docs.python.org/3/library/asyncio-task.html][https_docs.python.org_3_library_asyncio-task.html]

百度：[https://wenku.baidu.com/view/a52ac722a22d7375a417866fb84ae45c3b35c24e.html][https_wenku.baidu.com_view_a52ac722a22d7375a417866fb84ae45c3b35c24e.html]

博客：[https://www.jianshu.com/p/e38ee24dd004][https_www.jianshu.com_p_e38ee24dd004]

博客：[https://www.liaoxuefeng.com/wiki/1016959663602400/1017968846697824][https_www.liaoxuefeng.com_wiki_1016959663602400_1017968846697824]

[20191229135548559.png]: https://img-blog.csdnimg.cn/20191229135548559.png
[20191229135217592.png]: https://img-blog.csdnimg.cn/20191229135217592.png
[20191229135306788.png]: https://img-blog.csdnimg.cn/20191229135306788.png
[20191229140829873.png]: https://img-blog.csdnimg.cn/20191229140829873.png
[https_docs.python.org_3_library_asyncio-task.html]: https://docs.python.org/3/library/asyncio-task.html
[https_wenku.baidu.com_view_a52ac722a22d7375a417866fb84ae45c3b35c24e.html]: https://wenku.baidu.com/view/a52ac722a22d7375a417866fb84ae45c3b35c24e.html
[https_www.jianshu.com_p_e38ee24dd004]: https://www.jianshu.com/p/e38ee24dd004
[https_www.liaoxuefeng.com_wiki_1016959663602400_1017968846697824]: https://www.liaoxuefeng.com/wiki/1016959663602400/1017968846697824