Quand dois-je utiliser « attendre » de Python 3.5 et quand dois-je l'éviter ?

Quand adopter et quand éviter l'attente de Python 3.5

Dans Python 3.5, l'introduction d'asyncio et d'attente met la programmation asynchrone au premier plan. Ce changement de paradigme permet une plus grande concurrence et une exécution plus rapide, mais ses limites peuvent prêter à confusion. Cet article explore les subtilités de savoir quand employer et quand éviter l'attente.

Adoption de l'attente pour les opérations d'E/S

La principale raison d'adopter l'attente réside dans sa capacité à exploiter les puissance du code asynchrone. Considérez les opérations d'E/S telles que les requêtes réseau ou les lectures de fichiers. L'exécution synchrone de ces opérations bloque généralement l'intégralité du programme, l'obligeant à attendre la fin de chaque tâche. En revanche, le code asynchrone permet à ces opérations d'être exécutées simultanément, libérant ainsi le programme pour gérer d'autres tâches.

# 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: 5 sec. (plus asyncio overhead)

Dans l'exemple ci-dessus, l'approche asynchrone se termine en deux fois moins de temps, minimisant ainsi le temps perdu. en attente des opérations d'E/S.

S'abstenir de toute utilisation abusive de wait pour le code synchrone

Bien que wait excelle dans la gestion opérations d’E/S, elle ne doit pas être appliquée sans discernement au code synchrone. Le code synchrone, tel que les tâches liées au processeur ou la simple manipulation de données, ne bénéficie pas du paradigme asynchrone et peut en fait introduire une surcharge inutile.

# Synchronous Code That Should Remain Synchronous
def parse(html):
    # This function does not involve any I/O operations.
    links = extract_links_from_html(html)
    return links

Transformer le code synchrone en asynchrone ne sert à rien et peut conduire à un dégradation des performances.

Considérations spéciales pour les opérations synchrones de longue durée

Un aspect crucial à prendre en compte lors de l'utilisation d'asyncio est la impact des opérations synchrones de longue durée sur l’écosystème asynchrone. Les opérations synchrones dont l'exécution prend une période prolongée (par exemple, plus de 50 ms) peuvent potentiellement geler toutes les opérations asynchrones en cours d'exécution.

async def extract_links(url):
    data = await download(url)
    links = parse(data)
    # If search_in_very_big_file() takes a long time,
    # all ongoing async functions (elsewhere in code) will be suspended.
    links_found = search_in_very_big_file(links)

Pour éviter ce gel, envisagez d'exécuter ces opérations de longue durée dans un processus distinct ou en utilisant des pools de threads pour les opérations liées aux E/S dans le contexte asynchrone.

En conclusion, wait dans Python 3.5 doit être utilisé judicieusement lorsque gérer les opérations d'E/S pour exploiter les avantages de la concurrence. Cependant, cela doit être évité pour le code synchrone et les opérations de longue durée au sein de l’écosystème asynchrone afin d’éviter d’éventuels problèmes de performances et goulots d’étranglement. Un examen attentif de ces principes garantira une utilisation efficace des capacités asynchrones de Python 3.5.

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!