如何等待Python asyncio call_later完成所有未决

Question

I want to write a program that utilizes call_later to signal something (or things) to happen later, which themselves might add more routines to be invoked, and then signal to the program to run until there's nothing remaining to be run. For an example, I can do the following:

import  asyncio
START_RATE = 1

async def say_hi(who):
    print(f'hello {who}')

async def call_later(t, func, *params):
    await asyncio.sleep(t)
    await func(*params)

def run():
    # Let's go!
    incr = START_RATE
    loop = asyncio.get_event_loop()
    tasks = []
    for x in range(5):
        wait_delta = 5 - x
        tasks.append(
            call_later(incr * wait_delta, say_hi, x)
        )

    loop.run_until_complete(asyncio.gather(*tasks))

run()

But you'll notice that call_later is a bespoke coroutine.

Is it possible to use the event loop's call_later , but somehow inspect the event loop or otherwise await the completion of all pending callbacks?

Answer 1

You may introspect using asyncio.all_tasks() but it's probably the wrong way to do it.

The right way would be to create futures and allow call_later to mark them as done:

import asyncio
from functools import partial
START_RATE = 1


def say_hi(who):
    print(f'hello {who}')


def run_on_finish(callback):
    def wrapper(func, *args, **kwargs):
        try:
            return func(*args, **kwargs)
        finally:
            callback()
    return wrapper


def release_waiter(waiter, *args):
    """Taken from standard library"""
    if not waiter.done():
        waiter.set_result(None)


def run():
    # Let's go!
    incr = START_RATE
    loop = asyncio.get_event_loop()
    tasks = []
    for x in range(5):
        wait_delta = 5 - x

        # Create a waiter
        waiter = loop.create_future()
        release_cb = partial(release_waiter, waiter)

        # Schedule the function, making sure we release the waiter on finish
        handle = loop.call_later(incr * wait_delta, run_on_finish(release_cb),
                                 say_hi, x)

        # If waiter is cancelled, cancel the handle too.
        waiter.add_done_callback(lambda *args: handle.cancel)

        tasks.append(waiter)

    loop.run_until_complete(asyncio.gather(*tasks))


run()

Keep in mind call_later is used for normal functions and not coroutines. If say_hi needs to be a coroutine, you should add ensure_future or loop.create_task into the mix.

Adding them does come with more complications - you'll need to add a few more functions to take ensure_future 's resulting future, and chain it with your waiter in a similar way to futures._chain_future .

I highly suggest using your own coroutine in that case, as you have already done.