web-dev-qa-db-fra.com

Pourquoi la plupart des exemples asynchrones utilisent-ils loop.run_until_complete ()?

Je parcourais la documentation Python pour asyncio et je me demande pourquoi la plupart des exemples utilisent loop.run_until_complete() par opposition à Asyncio.ensure_future().

Par exemple: https://docs.python.org/dev/library/asyncio-task.html

Il semble que ensure_future Serait une bien meilleure façon de démontrer les avantages des fonctions non bloquantes. run_until_complete D'autre part, bloque la boucle comme le font les fonctions synchrones.

Cela me donne l'impression que je devrais utiliser run_until_complete Au lieu d'une combinaison de ensure_future Avec loop.run_forever() pour exécuter plusieurs co-routines simultanément.

python-3.xpython-asyncio
20
SamuelN

run_until_complete est utilisé pour exécuter un futur jusqu'à ce qu'il soit terminé. Il bloquera l'exécution du code qui le suit. Cependant, cela provoque l'exécution de la boucle d'événements. Tous les contrats à terme planifiés seront exécutés jusqu'à ce que l'avenir soit passé à run_until_complete est fait.

Étant donné cet exemple:

import asyncio

async def do_io():
    print('io start')
    await asyncio.sleep(5)
    print('io end')

async def do_other_things():
    print('doing other things')

loop = asyncio.get_event_loop()

loop.run_until_complete(do_io())
loop.run_until_complete(do_other_things())

loop.close()

do_io s'exécutera. Une fois terminé, do_other_things s'exécutera. Votre sortie sera:

io start
io end
doing other things

Si vous planifiez do_other_things avec la boucle d'événement avant d'exécuter do_io, le contrôle passera de do_io à do_other_things quand le premier attend.

loop.create_task(do_other_things())
loop.run_until_complete(do_io())

Cela vous donnera la sortie de:

doing other things
io start
io end

Ceci est dû au fait do_other_things était prévu avant le do_io. Il existe de nombreuses façons d'obtenir la même sortie, mais celle qui a du sens dépend vraiment de ce que fait réellement votre application. Je laisse donc cela comme un exercice au lecteur.

24
dirn