Quand dois-je utiliser « wait » dans la programmation asynchrone Python 3.5 et quelles sont ses limites ?

Quand employer et limites de wait dans Python 3.5

L'asynchronie dans Python 3.5 est principalement facilitée par la bibliothèque asyncio et l'async/ syntaxe d'attente. Comprendre quand et où exploiter ces constructions peut être crucial pour optimiser les performances de vos applications asynchrones.

La décision d'utiliser wait doit dépendre de la nature de votre code. Par défaut, votre code s'exécutera de manière synchrone. Pour introduire l'asynchronie, vous pouvez définir des fonctions à l'aide de async def et les invoquer avec wait. Cependant, il est important de déterminer si le code synchrone ou asynchrone est plus approprié pour la tâche à accomplir.

En règle générale, il est avantageux d'utiliser wait lors des opérations d'E/S. Les opérations d'E/S, telles que les requêtes réseau ou les appels de base de données, sont souvent intrinsèquement asynchrones et peuvent être considérablement accélérées en les déléguant à la boucle d'événements.

Par exemple, considérons le code synchrone suivant :

download(url1)  # takes 5 seconds
download(url2)  # takes 5 seconds
# Total time: 10 seconds

En utilisant asyncio et wait, le même code peut être réécrit de manière asynchrone, réduisant ainsi le temps d'exécution total au temps nécessaire pour le plus long opération :

await asyncio.gather(
    async_download(url1),  # takes 5 seconds
    async_download(url2),   # takes 5 seconds
)
# Total time: only 5 seconds (plus minimal asyncio overhead)

Il est également important de noter que toute fonction asynchrone peut utiliser librement du code synchrone si nécessaire. Cependant, la conversion de code synchrone en asynchrone sans raison valable doit être évitée, car cela n'introduit aucun avantage en soi.

Une considération cruciale avec le code asynchrone est la possibilité que des opérations synchrones de longue durée gèlent l'intégralité du programme. . Toute opération synchrone qui dépasse un certain seuil (par exemple, 50 millisecondes) peut bloquer toutes les tâches asynchrones simultanées.

Pour atténuer ce problème, vous pouvez sous-traiter ces opérations à un processus distinct et attendre leurs résultats :

executor = ProcessPoolExecutor(2)

async def extract_links(url):
    ...
    # If search_in_very_big_file() is a long synchronous operation, offload it to a separate process
    links_found = await loop.run_in_executor(executor, search_in_very_big_file, links)

Enfin, il convient de noter que les fonctions synchrones liées aux E/S peuvent être intégrées dans du code asynchrone à l'aide de run_in_executor() avec un ThreadPoolExecutor pour minimiser la surcharge associée au multitraitement.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!