Python : concurrence

Sommaire :

• Parallélisme et concurrence
• GIL
• Coroutines
• Asyncio

Parallélisme et concurrence

• - Parallélisme : exécution smilutanée de plusieurs tâches, sur plusieurs cœurs.
  • Utile pour les tâches intenses en calcul (CPU bound tasks).
• - Concurrence : exécution de plusieurs tâches dans un ordre quelconque, sur un seul cœur.
  • Utile pour les tâches intenses en entrées / sorties (I/O bound tasks).

GIL

Le Global Interpreter Lock (GIL) est un verrou (mutex) qui empêche l'exécution simultanée de plusieurs threads Python.
Ça rend le code de l'interpréteur Python thread-safe en évitant les situations de compétition (race condition) pour la mise à jour des compteurs de référence de CPython.
Le GIL est un mécanisme très efficace pour les programmes mono-thread et les programmes limités par les I/O.
Référence : What Is the Python Global Interpreter Lock (GIL)?.

Coroutines

Les coroutines sont des fonctions qui interagissent via yield et send : yield donne la valeur envoyée pendant la pause via send (ou None par défaut).

def counter(x):
    n = 0
    while n <= x:
        v = (yield n)
        if v is not None:
            n = v
        else:
            n += 1

generator = counter(25)
for i in generator:
    print i
    # When at 15, jump to 18
    if i == 15:
        generator.send(18)

Asyncio

Asyncio est une bibliothèque permettant d'implémenter des tâches concurrentes.
Le cœur de Asyncio est l'event loop qui permet une programmation événementielle.

Définition d'une fonction coroutine : async def.
L'appel à une fonction coroutine retourne un objet coroutine.
Depuis une coroutine (mais seulement depuis une coroutine), on peut appeler une autre coroutine en faisant un await, qui indique qu'on est disposé à rendre la main.
Exemple :

import asyncio

async def hello_world():
    await asyncio.sleep(0.2)
    print("Hello World")

asyncio.run(hello_world())

On peut utiliser des constructions avancées telles :

• - Itérateurs asynchrones : async for.
• - Compréhensions asynchrones.
• - Context managers asynchrones : async with.

ensure_future() retourne une Task.

La dernière mise à jour de cette page date de mai 2024.

Le contenu de ce site est, en tant qu'œuvre originale de l'esprit, protégé par le droit d'auteur.
Pour tout commentaire, vous pouvez m'écrire à xavier.lamorlette@gmail.com.