"Огонь и забыть" python async/wait

Ответ 1

Upd:

Замените asyncio.ensure_future везде на asyncio.create_task если вы используете Python> = 3.7 Это более новый, более хороший способ порождать задачу.

asyncio.Task "уволить и забыть"

В соответствии с документами Python для asyncio.Task можно запустить некоторую сопрограмму для выполнения "в фоновом режиме". Задача, созданная функцией asyncio.ensure_future, не будет блокировать выполнение (поэтому функция вернется немедленно!). Это похоже на способ "выстрелить и забыть", как вы просили.

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

Выход:

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

Что если задачи выполняются после завершения цикла событий?

Обратите внимание, что asyncio ожидает, что задача будет выполнена в тот момент, когда завершится цикл событий. Так что если вы измените main() на:

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

Вы получите это предупреждение после завершения программы:

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

Чтобы предотвратить это, вы можете просто дождаться выполнения всех ожидающих задач после завершения цикла событий:

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 also finish all running tasks:
    pending = asyncio.Task.all_tasks()
    loop.run_until_complete(asyncio.gather(*pending))

Убивайте задачи, а не ожидайте их

Иногда вы не хотите ждать выполнения задач (например, некоторые задачи могут быть созданы для вечного выполнения). В этом случае вы можете просто отменить() их, а не ждать их:

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 also cancel all running tasks:
    pending = asyncio.Task.all_tasks()
    for task in pending:
        task.cancel()
        # Now we should await task to execute it cancellation.
        # Cancelled task raises asyncio.CancelledError that we can suppress:
        with suppress(asyncio.CancelledError):
            loop.run_until_complete(task)

Выход:

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

Ответ 2

Это не совсем асинхронное выполнение, но, возможно, вам подходит run_in_executor().

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)

Ответ 3

Спасибо Сергей за лаконичный ответ. Вот украшенная версия того же.

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

Производит

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