“Dispare e esqueça” python async / await

Às vezes, há alguma operação assíncrona não crítica que precisa acontecer, mas eu não quero esperar que ela seja concluída. Na implementação de co-rotina do Tornado, você pode "disparar e esquecer" uma função assíncrona simplesmente omitindo a yieldpalavra-chave.

Tenho tentado descobrir como "disparar e esquecer" com a nova async/ awaitsintaxe lançada no Python 3.5. Por exemplo, um snippet de código simplificado:

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

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

bar()

O que acontece é que isso bar()nunca é executado e, em vez disso, recebemos um aviso de tempo de execução:

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

Upd:

Substitua asyncio.ensure_futurepor asyncio.create_taskqualquer lugar se estiver usando Python> = 3.7. É uma maneira mais nova e mais agradável de gerar tarefas .

asyncio. Peça para “disparar e esquecer”

De acordo com a documentação do python asyncio.Task, é possível iniciar alguma co-rotina para executar "em segundo plano" . A tarefa criada pela asyncio.ensure_future função não bloqueará a execução (portanto, a função retornará imediatamente!). Parece uma forma de “disparar e esquecer” conforme solicitado.

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

Resultado:

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

E se as tarefas estiverem sendo executadas após a conclusão do loop de evento?

Observe que asyncio espera que a tarefa seja concluída no momento em que o loop de eventos for concluído. Então, se você mudar main()para:

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

Você receberá este aviso após a conclusão do programa:

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

Para evitar isso, você pode apenas aguardar todas as tarefas pendentes após a conclusão do loop de eventos:

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

Mate tarefas em vez de esperá-las

Às vezes, você não quer esperar que as tarefas sejam realizadas (por exemplo, algumas tarefas podem ser criadas para serem executadas para sempre). Nesse caso, você pode simplesmente cancelá-los () em vez de aguardá-los:

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)

Resultado:

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

Obrigado, Sergey pela resposta sucinta. Aqui está a versão decorada do mesmo.

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

Produz

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

Nota: verifique minha outra resposta, que faz o mesmo usando tópicos simples.

Esta não é uma execução totalmente assíncrona, mas talvez run_in_executor () seja adequado para você.

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)

Por alguma razão, se você não puder usar asyncio, aqui está a implementação usando threads simples. Verifique minhas outras respostas e a resposta de Sergey também.

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