ensure_future vs create_task

ensure_future est une méthode pour créer Task à partir de coroutine . Il crée des tâches de différentes façons basées sur l'argument (y compris l'utilisation de create_task pour les coroutines et les objets similaires à ceux du futur).

create_task est une méthode abstraite de AbstractEventLoop . Différentes boucles d'événements peuvent implémenter cette fonction de différentes façons.

Vous devez utiliser ensure_future pour créer des tâches. Vous n'aurez besoin de create_task que si vous voulez implémenter votre propre type de boucle d'événement.

Upd:

@bj0 pointait à la réponse de Guido sur ce sujet:

le point de ensure_future() est si vous avez quelque chose qui pourrait soit une coroutine, soit un Future (ce dernier comprenant Task parce que c'est une sous-classe de Future ), et vous voulez être en mesure d'appeler une méthode sur ce qui est défini sur Future (probablement la seule utile exemple: cancel() ). Quand il est déjà un Future (ou Task ) ce ne fait rien; quand il est une coroutine il wraps il dans un Task .

Si vous savez que vous avez une coroutine et vous voulez qu'il soit prévu, la bonne API pour l'utilisation est create_task() . Le seul moment où vous devriez appeler ensure_future() est quand vous fournissez une API (comme la plupart de L'APIs d'asyncio) qui accepte soit une corotine soit un Future et vous devez faire quelque chose qui vous oblige à avoir un Future .

et plus tard:

en fin de compte, je crois toujours que ensure_future() est un nom obscur pour un morceau de fonctionnalité. Lors de la création d' une tâche d'une coroutine vous devez utiliser le nom approprié loop.create_task() . Peut-être qu'il devrait y avoir un pseudonyme pour ça. asyncio.create_task() ?

C'est surprenant pour moi. Ma principale motivation pour utiliser ensure_future tout au long était que c'est fonction de niveau plus élevé par rapport au membre de loop create_task (discussion contient quelques idées comme ajouter asyncio.spawn ou asyncio.create_task ).

je peux également souligner que, à mon avis, il est assez commode d'utiliser une fonction universelle qui peut gérer n'importe quel Awaitable plutôt que coroutines seulement.

cependant, la réponse de Guido est claire: "lors de la création d'une tâche à partir d'une coroutine, vous devez utiliser le nom approprié loop.create_task()

quand les coroutines devraient être enveloppées dans des tâches?

envelopper coroutine dans une tâche - est une façon de commencer ce coroutine "en arrière-plan". Exemple:

import asyncio


async def msg(text):
    await asyncio.sleep(0.1)
    print(text)


async def long_operation():
    print('long_operation started')
    await asyncio.sleep(3)
    print('long_operation finished')


async def main():
    await msg('first')

    # Now you want to start long_operation, but you don't want to wait it finised:
    # long_operation should be started, but second msg should be printed immediately.
    # Create task to do so:
    task = asyncio.ensure_future(long_operation())

    await msg('second')

    # Now, when you want, you can await task finised:
    await task


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

sortie:

first
long_operation started
second
long_operation finished

vous pouvez remplacer asyncio.ensure_future(long_operation()) par juste await long_operation() pour sentir la différence.