Python?Asyncio庫之asyncio.task常用函數有哪些

這篇文章主要介紹“Python Asyncio庫之asyncio.task常用函數有哪些”的相關知識，小編通過實際案例向大家展示操作過程，操作方法簡單快捷，實用性強，希望這篇“Python Asyncio庫之asyncio.task常用函數有哪些”文章能幫助大家解決問題。

0.基礎

在《Python Asyncio調度原理》中介紹了Asyncio的兩種調度基本單位，Handler和TimeHandler，他們只能被loop.call_xx函數調用，開發者從表面上不知道他們的存在，他們和loop.call_xx屬于事件循環的基礎功能，但是這些操作都屬于單一操作，需要開發者自己編寫代碼把他們的操作給串聯起來。 而在《Python的可等待對象在Asyncio的作用》中介紹了協程鏈的發起者asyncio.Task能通過loop.call_soon跟事件循環進行交互，并串聯整個協程鏈中可等待對象以及安排可等待對象的運行。 不過對于loop.call_at和loop.call_later仍需要開發者通過asyncio.Future來把Timehandler的執行結果與asyncio.Task給串聯起來，比如休眠一秒的代碼實現：

import asyncio


async def main():
    loop = asyncio.get_event_loop()
    f = asyncio.Future()

    def _on_complete():
        f.set_result(True)

    loop.call_later(1, _on_complete)
    return await f


if __name__ == "__main__":
    import time
    s_t = time.time()
    asyncio.run(main())
    print(time.time() - s_t)

這段代碼中asyncio.Future執行的是類似容器的功能，自己本身會接受各種狀態，并把自己的狀態同步給管理當前協程鏈的asyncio.Task，使asyncio.Task能管理其他類型的操作。 在asyncio.tasks模塊中的所有功能函數的原理也差不多，他們接受的參數基本是都是可等待對象，然后通過asyncio.Futurte作為容器來同步調用端和可等待對象間的狀態，也可以通過其他的一些方法把asyncio.Task的狀態同步給可等待對象。

1.休眠--asyncio.sleep

asyncio.sleep是一個常用的方法，開發者通過它可以很方便的讓協程休眠設定的時間，它本身也非常簡單，它的源碼如下:

@types.coroutine
def __sleep0():
    yield


async def sleep(delay, result=None):
    """Coroutine that completes after a given time (in seconds)."""
    if delay <= 0:
        await __sleep0()
        return result

    loop = events.get_running_loop()
    future = loop.create_future()
    h = loop.call_later(delay,
                        futures._set_result_unless_cancelled,
                        future, result)
    try:
        return await future
    finally:
        h.cancel()

通過源碼可以發現當設置的休眠時間等于小于0的時候，sleep只執行了yield，并不會執行其他邏輯，而在值大于0時會創建一個Future對象，接著就一直等待，直到Future對象被loop.call_later控制結束時才返回結果值。

需要注意的是，當asyncio.sleep在值為0時，sleep執行yield可以讓Task.__step感知而讓出控制權，這是最小的讓出當前協程控制權的方法，所以我們在編寫涉及到CPU比較多的時候或者消耗時間較長的函數時可以通過asyncio.sleep(0)來主動讓出控制權，如下:

import asyncio

async def demo() -> None:
    for index, i in enumerate(range(10000)):
        if index % 100 == 0:
            await asyncio.sleep(0)
        ...  # 假設這里的代碼占用過多的CPU時間

在這個例子中每循環100次就讓出控制權，以減少對其他協程的影響。

2.屏蔽取消--asyncio.shield

asyncio.shield可以保護一個可等待對象被取消，或者說是防止協程鏈上的取消傳播到被asyncio.shield托管的可等待對象，但是調用可等待對象的cancel方法仍然可以取消可等待對象的運行，如下例子：

import asyncio


async def sub(f):
    await asyncio.shield(f)


async def main():
    f1 = asyncio.Future()
    f2 = asyncio.Future()
    sub1 = asyncio.create_task(sub(f1))
    sub2 = asyncio.create_task(sub(f2))
    f1.cancel()
    sub2.cancel()
    await asyncio.sleep(0)  # 確保已經取消完成
    print("f1 future run success:", f1.done())
    print("f2 future run success:", f2.done())
    print("sub1 future run result:", sub1.done())
    print("sub2 future run result:", sub2.done())

asyncio.run(main())

# >>> future run success: True
# >>> future run success: False
# >>> sub1 future run result: True
# >>> sub2 future run result: True

其中f1, f2都在main函數中創建， 然后同時被sub函數包裹，并通過asyncio.create_task在后臺異步運行并分別返回sub1和sub2兩個Future對應著sub函數的執行情況。 接著分別取消f1和sub2的執行，并把f1,f2,sub1,sub2是否為done打印出來，可以發現f1,sub1,sub2的狀態都為done（被取消也認為是done)，而f2則還在運行中。

在文章《Python的可等待對象在Asyncio的作用》中說過，一條協程鏈是由asyncio.Task牽頭組成的，后續的所有成功和異常都會在這條鏈上傳播，而取消本質上就是一種異常，所以也可以在協程鏈上傳播。 而shield為了杜絕運行的可等待對象收到協程鏈的異常傳播又能讓協程鏈知道可等待對象的執行結果，會先讓可等待對象在另外一條協程鏈運行，然后創建一個容器接到原來鏈上，并在可等待對象執行完成的時候把結果告訴容器，由容器把結果傳播到原有的協程鏈上，對應的源碼如下:

def shield(arg):
    # 如果是Coro，則需要包裝成future
    inner = _ensure_future(arg)
    if inner.done():
        # 如果已經完成，就不需要被處理了
        return inner
    loop = futures._get_loop(inner)
    # 創建一個future容器
    outer = loop.create_future()

    def _inner_done_callback(inner):
        if outer.cancelled():
            if not inner.cancelled():
                # 如果容器已經被取消，而自己沒被取消且已經完成，則手動獲取下結果，方便被回收
                inner.exception()
            return

        if inner.cancelled():
            # 如果自己被取消，則把取消通過容器傳播到協程鏈上
            outer.cancel()
        else:
            # 自己已經完成且容器未完成，把自己的結果或者異常通過替身傳播到協程鏈上
            exc = inner.exception()
            if exc is not None:
                outer.set_exception(exc)
            else:
                outer.set_result(inner.result())


    def _outer_done_callback(outer):
        if not inner.done():
            inner.remove_done_callback(_inner_done_callback)

    # 添加回調，在執行成功或被取消時通知對方
    inner.add_done_callback(_inner_done_callback)
    outer.add_done_callback(_outer_done_callback)
    return outer

通過源碼可以發現shield被調用的時候(假設驅動調用shield的Task名為main.Task)，會先通過_ensure_future輔助函數創建一個Task(other.Task)在后臺異步運行可等待對象，驅動可等待對象的運行，由于是新的Task驅動著可等待對象的執行，所以main.Task的任何狀態不會傳播到當前的可等待對象。 接著創建一個Future容器，并在other.Task和Future容器掛上完成的回調使他們在完成的時候都能通知到對方，最后返回Future容器給main.Task，使main.Task能夠間接的知道可等待對象的運行結果，如下圖：

不過Future容器完成的回調只是把托管可等待對象的other.Task回調給移除了，導致main.Task的狀態不會同步到other.Task中(圖中Future通知可等待對象aws的通道是不通的)，進而不會影響到托管的可等待對象。 而other.Task完成的回調會把任何狀態同步到Future中，進而影響到main.Task。

3.超時--asyncio.wait_for

asyncio.wait_for可以托管可等待對象，直到可等待對象完成，不過可等待對象在設定的時間內還沒執行完成時會被直接取消執行并拋出asyncio.TimeoutError異常。 它的運行原理綜合了上面的asyncio.shield和asyncio.sleep，它一樣會為可等待對象創建一個Future容器,并在容器上掛了一個超時的回調和可等待對象執行結束的回調，接著就等待容器執行結束。 不過在了解asyncio.wait_for之前，先了解他用到的兩個輔助函數_cancel_and_wait和_release_waiter，他們的源碼如下:

def _release_waiter(waiter, *args):
    if not waiter.done():
        waiter.set_result(None)

async def _cancel_and_wait(fut, loop):
    waiter = loop.create_future()
    cb = functools.partial(_release_waiter, waiter)
    fut.add_done_callback(cb)

    try:
        fut.cancel()
        await waiter
    finally:
        fut.remove_done_callback(cb)

可以看出源碼比較簡單，他們的作用都是為了確保可等待對象能完全執行結束才返回，其中_release_waiter是確保可等待對象一定被設置為執行結束，而_cancel_and_wait是為了確保能等到可等待對象被取消且完整結束時才返回。

可等待對象的cancel方法可以認為是異步的，調用后需要等事件循環再次調用可等待對象時，可等待對象才會被取消。而_cancel_and_wait通過一個容器來規避這個問題，使取消這個操作變為同步的，這個方法在某些開發場景經常被使用，如果不是私有API就更好了。

接下來就可以通過wait_for的源碼了解他的執行邏輯了，源碼如下：

async def wait_for(fut, timeout):
    loop = events.get_running_loop()

    if timeout is None:
        return await fut

    if timeout <= 0:
        # 當超時的值小于等于0時就意味著想馬上得到結果
        
        fut = ensure_future(fut, loop=loop)

        if fut.done():
            # 如果執行完成就返回可等待對象的數據
            return fut.result()
        # 取消可等待對象并等待
        await _cancel_and_wait(fut, loop=loop)
        # 如果被_cancel_and_wait取消，那么會拋出CancelledError異常，這時候把它轉為超時異常
        try:
            return fut.result()
        except exceptions.CancelledError as exc:
            raise exceptions.TimeoutError() from exc

    # 初始化一個Future,只有在超時和完成時才會變為done
    waiter = loop.create_future()
    timeout_handle = loop.call_later(timeout, _release_waiter, waiter)
    cb = functools.partial(_release_waiter, waiter)

    fut = ensure_future(fut, loop=loop)
    fut.add_done_callback(cb)

    try:
        try:
            await waiter
        except exceptions.CancelledError:
            # 此時是asyncio.Task被取消，并把取消傳播到waiter
            if fut.done():
                return fut.result()
            else:
                # 如果任務被取消了，那么需要確保任務沒有被執行才返回
                fut.remove_done_callback(cb)
                await _cancel_and_wait(fut, loop=loop)
                raise
        # 計時結束或者是執行完畢的情況
        if fut.done():
            # 執行完畢，返回對應的值
            return fut.result()
        else:
            # 計時結束，清理資源，并拋出異常
            fut.remove_done_callback(cb)
            # 如果任務被取消了，那么需要確保任務沒有被執行才返回
            await _cancel_and_wait(fut, loop=loop)
            # 如果被_cancel_and_wait取消，那么會拋出CancelledError異常，這時候把它轉為超時異常
            try:
                return fut.result()
            except exceptions.CancelledError as exc:
                raise exceptions.TimeoutError() from exc
    finally:
        timeout_handle.cancel()

wait_for的源碼為了兼容各種情況，代碼復雜度比較高，同時超時參數小于等于0跟大于0的邏輯是一樣的，分開寫只是為了避免在小于等于0時創建了一些額外的對象，在精簡了一些asyncio.Task傳播異常給waiter的邏輯后，wait_for的執行邏輯如下圖：

fut為可等待對象，timeout為超時時間

可以看到wait_for的主要邏輯是先創建一個名為waiter的容器，接著通過loop.call_later指定在多少時間后釋放容器，然后再通過ensure_future使另一個asyncio.Task來托管可等待對象，并安排執行完畢的時候釋放容器，再等待waiter容器的執行直到被釋放。當容器被釋放的時候再判斷可等待對象是否執行完畢，如果執行完畢了就直接返回，否則拋出超時異常。

4.簡單的等待--wait

asyncio.wait用于等待一批可等待對象，當有一個可等待對象執行完成或者出現異常的時候才會返回數據(具體還是要看return_when指定的條件，默認為所有等待對象結束或取消時才返回)，需要注意的是wait雖然支持timeout參數，但是在超時的試試不會取消可等待對象，也不會拋出超時的異常，只會把完成的可等待對象放在完成的集合，把未完成的可等待對象放在未完成的集合并返回，如下代碼：

import asyncio


async def main():
    return await asyncio.wait(
        {asyncio.create_task(asyncio.sleep(1))},
        timeout=0.5
    )


if __name__ == "__main__":
    asyncio.run(main())

這段代碼可以正常的運作，不會拋出超時錯，不過還要注意的是在后續版本中asyncio.wait只支持Task對象，如果想要傳入的是coro和Future對象，則需要開發者自己手動轉換。 wait的邏輯與wait_for類似，源碼如下：

async def _wait(fs, timeout, return_when, loop):
    assert fs, 'Set of Futures is empty.'
    waiter = loop.create_future()
    timeout_handle = None
    if timeout is not None:
        # 定義一個time handler,在timeout秒后通過`_release_waiter`完成.
        timeout_handle = loop.call_later(timeout, _release_waiter, waiter)
    counter = len(fs)

    def _on_completion(f):
        # 每個可等待對象執行完成的回調
        nonlocal counter
        counter -= 1
        if (counter <= 0 or
            return_when == FIRST_COMPLETED or
            return_when == FIRST_EXCEPTION and
             (not f.cancelled() and f.exception() is not None)
        ):
            # 如果所有任務執行完成，或者是第一個完成或者是第一個拋出異常時，
            # 意味著執行完成，需要取消time handler,并標記為完成
            if timeout_handle is not None:
                timeout_handle.cancel()
            if not waiter.done():
                waiter.set_result(None)
    # 為每個可等待對象添加回調
    for f in fs:
        f.add_done_callback(_on_completion)

    try:
        # 等待替身執行完成
        await waiter
    finally:
        # 取消time handler并移除回調(因為cancel是異步的)
        if timeout_handle is not None:
            timeout_handle.cancel()
        for f in fs:
            f.remove_done_callback(_on_completion)

    # 處理并返回done和pending，其中done代表完成，pending代表執行中。
    done, pending = set(), set()
    for f in fs:
        if f.done():
            done.add(f)
        else:
            pending.add(f)
    return done, pending

可以看到wait_for的復雜度沒有wait高，而且可以看到asyncio.wait是等waiter這個容器執行完并移除可等待對象上面的_on_completion回調后才把可等待對象按照是否完成區分到done和pending兩個集合，這樣的準確度比在_on_completion高一些，但是如果開發者在處理集合時觸發一些異步操作也可能導致pending集合中的部分可等待對象變為完成的，如下代碼:

import asyncio


async def main():
    f_list = [asyncio.Future() for _ in range(10)]
    done, pending = await asyncio.wait(f_list, timeout=1)
    print(len(done), len(pending))
    print([i for i in pending if i.done()])
    f_list[1].set_result(True)
    print([i for i in pending if i.done()])


if __name__ == "__main__":
    asyncio.run(main())
# >>> 0 10
# >>> []
# >>> [<Future finished result=True>]

通過輸出可以發現，在asyncio.wait執行完畢后，pending中的完成的元素只有0個，而在后續強制為其中的一個Future設置數據后，pending中完成的元素有1個了。

5.迭代可等待對象的完成--asyncio.as_completed

asyncio.wait的機制是只要被觸發就會返回，其他尚未完成的可等待對象需要開發者自己在處理，而asyncio.as_completed可以確保每個可等待對象完成返回數據或者超時時拋出異常，使用方法如下：

import asyncio


async def sub(i):
    await asyncio.sleep(i)
    return i


async def main():
    for f in asyncio.as_completed([sub(i) for i in range(5)], timeout=3):
        print(await f)


if __name__ == "__main__":
    asyncio.run(main())
# >>> 0
# >>> 1
# >>> 2
# >>> Traceback (most recent call last):
#       File "/home/so1n/github/demo_project/demo.py", line 18, in <module>
#         asyncio.run(main())
#       File "/usr/lib/python3.7/asyncio/runners.py", line 43, in run
#         return loop.run_until_complete(main)
#       File "/usr/lib/python3.7/asyncio/base_events.py", line 584, in run_until_complete
#         return future.result()
#       File "/home/so1n/github/demo_project/demo.py", line 14, in main
#         print(await f)
#       File "/usr/lib/python3.7/asyncio/tasks.py", line 532, in _wait_for_one
#         raise futures.TimeoutError
#     concurrent.futures._base.TimeoutError

該程序并發執行5個協程，其中執行最久的時間是5秒，而as_completed設置的超時為3秒。通過輸出可以發現，每當一個可等待對象執行結束時就會把數據拋出來，當超時則會拋出超時錯誤。為了能達每有一個可等待對象就返回一次數據的效果，as_completed通過一個隊列來維護數據的返回，它的源碼如下：

def as_completed(fs, *, timeout=None):
    from .queues import Queue  # Import here to avoid circular import problem.
    done = Queue()

    loop = events._get_event_loop()
    todo = {ensure_future(f, loop=loop) for f in set(fs)}
    timeout_handle = None

    def _on_timeout():
        # 超時時調用，需要注意的是，失敗時結果為空，所以要推送一個空的數據到隊列中
        # 在消費者發現元素為空時拋出錯誤
        for f in todo:
            f.remove_done_callback(_on_completion)
            done.put_nowait(None)  # Queue a dummy value for _wait_for_one().
        todo.clear()  # Can't do todo.remove(f) in the loop.

    def _on_completion(f):
        # 如果成功，就把Future推送到隊列中，消費者可以通過Future獲取到結果
        if not todo:
            return  # _on_timeout() was here first.
        todo.remove(f)
        done.put_nowait(f)
        if not todo and timeout_handle is not None:
            timeout_handle.cancel()

    async def _wait_for_one():
        f = await done.get()
        if f is None:
            # 如果元素為空，則證明已經超時了，要拋出異常
            raise exceptions.TimeoutError
        return f.result()

    for f in todo:
        f.add_done_callback(_on_completion)
    if todo and timeout is not None:
        timeout_handle = loop.call_later(timeout, _on_timeout)
    # 通過生成器語法返回協程函數，該協程函數可以獲取最近完成的可等待對象的結果
    for _ in range(len(todo)):
        yield _wait_for_one()

通過源碼可以發現可等待對象就像生產者一樣，執行結束的時候就會把結果投遞給隊列，同時as_completed會迭代跟可等待對象的數量一樣的_wait_for_one協程函數，供開發者消費數據。不過需要注意的是as_completed在超時的時候，并不會取消尚未完成的可等待對象，他們會變為不可控的狀態，在某些時候會造成內存溢出，如下示例代碼：

import asyncio
import random


async def sub():
    # 一半的幾率會被set一個值并返回，一半的幾率會卡死
    f = asyncio.Future()
    if random.choice([0, 1]) == 0:
        f.set_result(None)
    return await f


async def main():
    try:
        for f in asyncio.as_completed([sub() for i in range(5)], timeout=1):
            print(await f)
    except asyncio.TimeoutError:
        # 忽略超時
        pass
    # 統計未完成的sub任務
    cnt = 0
    for i in asyncio.all_tasks():
        if i._coro.__name__ == sub.__name__:
            cnt += 1
    print("runing task by name sub:", cnt)


if __name__ == "__main__":
    asyncio.run(main())
# >>> None
# >>> None
# >>> None
# >>> runing task by name sub: 2

通過結果(由于采用隨機，結果可能不一樣)可以發現，sub成功執行完成的數量有3個(輸出None)，而在as_completed觸發超時后仍有兩個sub在執行中，這時的兩個sub成為無人管理的可等待對象，除非開發者通過asyncio.all_tasks去找到他并清理掉，否則這幾個可等待對象會一直伴隨著程序運行，這很容易造成內存溢出。

關于“Python Asyncio庫之asyncio.task常用函數有哪些”的內容就介紹到這里了，感謝大家的閱讀。如果想了解更多行業相關的知識，可以關注億速云行業資訊頻道，小編每天都會為大家更新不同的知識點。