Quand devriez-vous utiliser la fonctionnalité « attendre » de Python 3.5 pour asyncio, et quand devriez-vous l'éviter ?

Quand utiliser et éviter la fonctionnalité wait de Python 3.5 pour Asyncio

Python 3.5 a introduit le mot-clé wait pour faciliter la programmation asynchrone avec asyncio. Cependant, il n'est pas toujours clair quelles opérations doivent être attendues pour maximiser l'efficacité.

Détermination des candidats asynchrones

Une règle empirique consiste à attendre toute fonction qui exécute un I/ O opération, comme l'accès au réseau ou la lecture de fichiers. Ces opérations peuvent potentiellement bloquer le code synchrone pendant une période prolongée. En les attendant, asyncio peut effectuer d'autres opérations simultanément.

Avantages du code asynchrone

Comme le démontre l'extrait de code ci-dessous, le code asynchrone peut accélérer considérablement les opérations qui impliquent appels E/S multiples :

# Synchronous way:
download(url1)  # takes 5 sec.
download(url2)  # takes 5 sec.
# Total time: 10 sec.

# Asynchronous way:
await asyncio.gather(
    async_download(url1),  # takes 5 sec. 
    async_download(url2)   # takes 5 sec.
)
# Total time: only 5 sec. (+ little overhead for using asyncio)

Fonctions avec mixte asynchrone/synchrone Code

Les fonctions asynchrones peuvent appeler à la fois des fonctions asynchrones et synchrones. Cependant, il n'y a aucun avantage à attendre du code synchrone qui n'effectue pas d'opérations d'E/S. Cela peut introduire une surcharge inutile :

async def extract_links(url):  

    # async_download() was created async to get benefit of I/O
    html = await async_download(url)  

    # parse() doesn't work with I/O, there's no sense to make it async
    links = parse(html)  

    return links

Éviter les opérations synchrones de longue durée

Il est crucial d'éviter les opérations synchrones de longue durée (> 50 ms) dans les opérations asynchrones. fonctions, car ils peuvent geler toutes les autres tâches asynchrones. Pour gérer ces tâches efficacement :

• Utiliser le multitraitement : Exécuter des opérations de longue durée dans un processus distinct et attendre le résultat :

executor = ProcessPoolExecutor(2)

async def extract_links(url):
    data = await download(url)
    links = parse(data)
    # Now your main process can handle another async functions while separate process running    
    links_found = await loop.run_in_executor(executor, search_in_very_big_file, links)

• Utilisez ThreadPoolExecutor : Pour les tâches synchrones liées aux E/S, telles que les requêtes vers un site Web serveur :

executor = ThreadPoolExecutor(2)

async def download(url):
    response = await loop.run_in_executor(executor, requests.get, url)
    return response.text

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!