Question

有时需要进行一些非关键的异步操作，但我不想等待它完成。在Tornado的协同程序实现中，您可以＆＃34; fire＆amp; amp;忘记＆＃34;通过简单地省略yield关键字来实现异步功能。

我一直试图弄清楚如何＆＃34;火＆amp;忘记＆＃34;使用Python 3.5中发布的新async / await语法。例如，简化的代码片段：

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

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

bar()

但是bar()永远不会执行，而是我们得到运行时警告：

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

Answer 1

<强> UPD：

如果您正在使用Python＆gt; = to spawn task，那么将asyncio.ensure_future替换为asyncio.create_task。

asyncio.Task to“fire and forget”

根据asyncio.Task的python文档，可以在背景＆＃34; 中启动一些协同程序执行＆＃34; asyncio.ensure_future function创建的任务不会阻止执行（因此函数将立即返回！）。这看起来就像你要求的那样“发射并忘记”。

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 [...]

为防止在事件循环完成后您只能await all pending tasks：

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

杀死任务而不是等待他们

有时您不想等待完成任务（例如，可能会创建一些任务以永久运行）。在这种情况下，你可以取消（）而不是等待它们：

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)

输出：

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

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

Answer 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

Answer 4

由于某种原因，如果您无法使用asyncio，那么这里是使用普通线程的实现

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

＆＃34;火与忘记＆＃34; python async / await

4 个答案:

asyncio.Task to“fire and forget”

如果在事件循环完成后执行任务会怎样？

杀死任务而不是等待他们