Python : concurrence

Sommaire :
• Parallélisme et concurrence
• GIL
• Coroutines
• Asyncio
• Sous-interpréteurs

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.

Sous-interpréteurs

À partir de Python 3.14, on peut utiliser des sous-interpréteurs. Les sous-interpréteurs sont à mi-chemin entre les interpréteurs, qui sont des processus lourds, et les threads, qui ne peuvent pas tourner en parallèle à cause du GIL. Chaque sous-interpréteur a son propre GIL et ses propres objets globaux. Il suffit d'utiliser InterpreterPoolExecutor de concurrent.futures (qui fonctionne comme ThreadPoolExecutor).

La dernière mise à jour de cette page date d'octobre 2025.

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.