Python协程

生产环境中经常有并发执行任务的需求，由于GIL的存在，Python的线程并不是真正意义上并行执行的线程，在Python2环境中，经常用greenlet/gevent替代并发执行，Python3有了自己的async/await关键字，可以简单地进行协程创建。
先看一个例子

# -*- coding: utf-8 -*-
import asyncio

async def main():
    print('start')
    await asyncio.sleep(2)
    print('end')

asyncio.run(main())

例子中一个协程和协程函数是等价的，创建一个协程函数使用async关键字，执行时使用asyncio.run(coroutine)

可等待对象

上面的例子中一个协程属于一个可等待对象，同时还是可等待对象的还有任务和Future

• 协程
• 任务
• Future

协程

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

任务执行

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

任务和顺序执行协程相比是同时开始的

Future

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

休眠

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

# -*- coding: utf-8 -*-
import asyncio
import datetime

async def display_date():
    loop = asyncio.get_running_loop()
    end_time = loop.time() + 5.0
    while True:
        print(datetime.datetime.now())
        if(loop.time()+1.0) >= end_time:
            break
        await asyncio.sleep(1)

asyncio.run(display_date())

并发运行任务

Awaitable asyncio.gather(*aws, loop=None, return_exceptions=False)
aws为序列中的可等待对象
如果return_exceptions为False， 所引发的首个异常会立即传播给等待gather()的任务。aws序列中的其他可等待对象不会被取消并将继续运行。
如果return_exceptions为True，异常会和成功的结果一样处理，并聚合至结果列表。
gather()的结果是一个由所有返回值聚合而成的列表。结果顺序与aws中可等待对象的顺序一致。
如果gather()被取消，所有未完成的可等待对象会被取消。如果任一个Task或者Future是对象被取消，它将被当做引发了CancelledError一样处理。

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}")
    return f

async def main():
    # Schedule three calls *concurrently*:
    result = await asyncio.gather(
        factorial("A", 2),
        factorial("B", 3),
        factorial("C", 4),
    )
    print(result)

asyncio.run(main())

如果希望获得跟aws顺序一样的结果，可以用这个办法

其他使用方法详见
协程与任务 — Python 3.7.5rc1 文档

学习/python