"Fire and Forget" python 비동기/대기

"Fire and Forget" python 비동기/대기

때로는 중요하지 않은 비동기 작업이 수행되어야 하지만 완료될 때까지 기다리고 싶지 않습니다.Tornado의 코루틴 구현에서 간단히 생략함으로써 비동기 기능을 "발사하고 잊어버릴" 수 있습니다.yield표제어

나는 새로운 것으로 "불을 지르고 잊어버리는" 방법을 찾으려고 노력해 왔습니다.async/await구문은 파이썬 3.5로 출시되었습니다. 예를 들어, 단순화된 코드 스니펫:

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

업데이트:

교체하다asyncio.ensure_future와 함께asyncio.create_task어디서나 Python >= 3.7 작업을 생성하는 새롭고 더 좋은 방법입니다.

---

비동기의"발사하고 잊어버리는" 작업

python 문서에 따르면 "백그라운드"에서 실행하기 위해 일부 코루틴을 시작할 수 있습니다.에 의해 생성된 작업은 실행을 차단하지 않습니다. 따라서 함수는 즉시 반환됩니다!이것은 당신이 요청한 대로 "발사하고 잊어버리는" 방법처럼 보입니다.

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

기다리는 대신 작업 중지

작업이 완료될 때까지 기다리지 않으려는 경우가 있습니다(예: 일부 작업은 영구적으로 실행되도록 생성될 수 있음).그런 경우에는 그냥.cancel()그들을 기다리는 대신에:

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

출력:

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

실행을 백그라운드로 밀어넣고 제어 라인을 코드의 다음 줄로 이동하는 간단한 데코레이터 기능이 있습니다.

주요 장점은 다음과 같이 함수를 선언할 필요가 없다는 것입니다.await

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():
    print("foo() started")
    time.sleep(1)
    print("foo() completed")

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

참고: 일반을 사용하여 동일한 다른 답변 확인thread없이.asyncio.

이는 완전히 비동기식 실행은 아니지만 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)

어떤 이유로 사용할 수 없는 경우asyncio그런 다음 일반 스레드를 사용한 구현이 있습니다.제 다른 답변과 세르게이의 답변도 확인해주세요.

import threading, time

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

    return wrapped

@fire_and_forget
def foo():
    print("foo() started")
    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

def fire_and_forget(f):
    def wrapped(*args, **kwargs):
        threading.Thread(target=functools.partial(f, *args, **kwargs)).start()

    return wrapped

위의 더 나은 버전입니다. 비동기를 사용하지 않습니다.

언급URL : https://stackoverflow.com/questions/37278647/fire-and-forget-python-async-await