"Spara e dimentica" Python async / await

A volte è necessario eseguire un'operazione asincrona non critica, ma non voglio aspettare che venga completata. Nell'implementazione coroutine di Tornado è possibile "sparare e dimenticare" una funzione asincrona semplicemente omettendo la yieldparola chiave.

Ho cercato di capire come "sparare e dimenticare" con la nuova sintassi async/ awaitrilasciata in Python 3.5. Ad esempio, uno snippet di codice semplificato:

async def async_foo():
    print("Do some stuff asynchronously here...")

def bar():
    async_foo()  # fire and forget "async_foo()"

bar()

Quello che succede però è che bar()non viene mai eseguito e invece otteniamo un avviso di runtime:

RuntimeWarning: coroutine 'async_foo' was never awaited
  async_foo()  # fire and forget "async_foo()"

UPD:

Sostituisci asyncio.ensure_futurecon asyncio.create_taskovunque se stai usando Python> = 3.7 È un modo più nuovo e più carino per generare attività .

asyncio.Task "sparare e dimenticare"

Secondo la documentazione di Python asyncio.Taskè possibile avviare alcune coroutine da eseguire "in background" . L'attività creata dalla asyncio.ensure_future funzione non bloccherà l'esecuzione (quindi la funzione tornerà immediatamente!). Sembra un modo per "sparare e dimenticare" come richiesto.

import asyncio


async def async_foo():
    print("async_foo started")
    await asyncio.sleep(1)
    print("async_foo done")


async def main():
    asyncio.ensure_future(async_foo())  # fire and forget async_foo()

    # btw, you can also create tasks inside non-async funcs

    print('Do some actions 1')
    await asyncio.sleep(1)
    print('Do some actions 2')
    await asyncio.sleep(1)
    print('Do some actions 3')


if __name__ == '__main__':
    loop = asyncio.get_event_loop()
    loop.run_until_complete(main())

Produzione:

Do some actions 1
async_foo started
Do some actions 2
async_foo done
Do some actions 3

Cosa succede se le attività vengono eseguite dopo il completamento del ciclo di eventi?

Nota che asyncio si aspetta che l'attività venga completata nel momento in cui il ciclo di eventi è completato. Quindi, se passerai main()a:

async def main():
    asyncio.ensure_future(async_foo())  # fire and forget

    print('Do some actions 1')
    await asyncio.sleep(0.1)
    print('Do some actions 2')

Riceverai questo avviso al termine del programma:

Task was destroyed but it is pending!
task: <Task pending coro=<async_foo() running at [...]

Per evitare ciò, puoi semplicemente attendere tutte le attività in sospeso dopo il completamento del ciclo di eventi:

async def main():
    asyncio.ensure_future(async_foo())  # fire and forget

    print('Do some actions 1')
    await asyncio.sleep(0.1)
    print('Do some actions 2')


if __name__ == '__main__':
    loop = asyncio.get_event_loop()
    loop.run_until_complete(main())

    # Let's also finish all running tasks:
    pending = asyncio.Task.all_tasks()
    loop.run_until_complete(asyncio.gather(*pending))

Uccidi i compiti invece di aspettarli

A volte non si desidera attendere il completamento delle attività (ad esempio, alcune attività potrebbero essere create per essere eseguite all'infinito). In tal caso, puoi semplicemente cancellarli () invece di aspettarli:

import asyncio
from contextlib import suppress


async def echo_forever():
    while True:
        print("echo")
        await asyncio.sleep(1)


async def main():
    asyncio.ensure_future(echo_forever())  # fire and forget

    print('Do some actions 1')
    await asyncio.sleep(1)
    print('Do some actions 2')
    await asyncio.sleep(1)
    print('Do some actions 3')


if __name__ == '__main__':
    loop = asyncio.get_event_loop()
    loop.run_until_complete(main())

    # Let's also cancel all running tasks:
    pending = asyncio.Task.all_tasks()
    for task in pending:
        task.cancel()
        # Now we should await task to execute it's cancellation.
        # Cancelled task raises asyncio.CancelledError that we can suppress:
        with suppress(asyncio.CancelledError):
            loop.run_until_complete(task)

Produzione:

Do some actions 1
echo
Do some actions 2
echo
Do some actions 3
echo

Grazie Sergey per la breve risposta. Ecco la versione decorata dello stesso.

import asyncio
import time

def fire_and_forget(f):
    def wrapped(*args, **kwargs):
        return asyncio.get_event_loop().run_in_executor(None, f, *args, *kwargs)

    return wrapped

@fire_and_forget
def foo():
    time.sleep(1)
    print("foo() completed")

print("Hello")
foo()
print("I didn't wait for foo()")

produce

>>> Hello
>>> foo() started
>>> I didn't wait for foo()
>>> foo() completed

Nota: controlla la mia altra risposta che fa lo stesso usando thread semplici.

Questa non è un'esecuzione completamente asincrona, ma forse run_in_executor () è adatto a te.

def fire_and_forget(task, *args, **kwargs):
    loop = asyncio.get_event_loop()
    if callable(task):
        return loop.run_in_executor(None, task, *args, **kwargs)
    else:    
        raise TypeError('Task must be a callable')

def foo():
    #asynchronous stuff here


fire_and_forget(foo)

Per qualche motivo, se non sei in grado di utilizzare, asyncioecco l'implementazione che utilizza thread semplici. Controlla le mie altre risposte e anche la risposta di Sergey.

import threading

def fire_and_forget(f):
    def wrapped():
        threading.Thread(target=f).start()

    return wrapped

@fire_and_forget
def foo():
    time.sleep(1)
    print("foo() completed")

print("Hello")
foo()
print("I didn't wait for foo()")