La coroutine jamais attendue The coroutine that's never awaited

Une coroutine est un objet en attente, pas un calcul en cours — le n°23 l'a montré. La conséquence la plus silencieuse de cette mécanique : coro() sans await ne s'exécute jamais, sans la moindre erreur bruyante. Et une tâche créée avec create_task, sans référence gardée quelque part, peut disparaître avant même d'avoir eu la chance de tourner. A coroutine is a waiting object, not a computation in progress — issue №23 showed that. The most silent consequence of that mechanic: coro() without await never runs, with no loud error at all. And a task created with create_task, with no reference kept anywhere, can vanish before it ever gets the chance to run.

Audience
Dev qui a vu RuntimeWarning: coroutine was never awaited dans ses logs et qui l'a ignoré Dev who's seen RuntimeWarning: coroutine was never awaited in their logs and ignored it
ChapitresChapters
5
LectureReading
≈ 19 min
NiveauLevel
●●●●
Date
Juil 2026 Jul 2026

asyncioCoroutinesTasks

SommaireContents ·
№ 01CadrageFraming3 min

Appeler une coroutine sans await ne l'exécute pas à moitié — elle ne s'exécute pas du tout.Calling a coroutine without await doesn't half-run it — it doesn't run at all.

Le numéro précédent l'a établi : appeler une fonction async def crée un objet coroutine en attente, sans exécuter son corps. La conséquence directe, et la plus silencieuse de toute la série, est celle-ci : si ce coro() n'est jamais donné à await, à asyncio.gather, ou à asyncio.create_task, l'objet reste en attente pour toujours — son corps ne s'exécute JAMAIS, ni maintenant, ni plus tard. Aucune exception n'est levée. Le seul signal est un RuntimeWarning affiché sur stderr, facile à noyer dans des logs bruyants, qui dit littéralement ce qui s'est passé : « coroutine was never awaited ».The previous issue established it: calling an async def function creates a waiting coroutine object without running its body. The direct, and most silent, consequence in this entire series is this: if that coro() is never handed to await, to asyncio.gather, or to asyncio.create_task, the object stays waiting forever — its body NEVER executes, not now, not later. No exception is raised. The only signal is a RuntimeWarning printed to stderr, easy to drown in noisy logs, which literally says what happened: 'coroutine was never awaited'.

Le corps de la coroutine ne s'exécute jamais -- ni le print, ni l'écriture en baseThe coroutine's body never runs -- not the print, not the database write
import asyncio

async def enregistrer_evenement(nom):
    print(f"écriture de {nom} en base...")
    await asyncio.sleep(0.1)
    print(f"{nom} enregistré")

async def main():
    enregistrer_evenement("connexion_utilisateur")   # PAS de await ici
    print("suite du programme")

asyncio.run(main())
# affiche seulement :
# suite du programme
# fichier.py:N: RuntimeWarning: coroutine 'enregistrer_evenement' was never awaited
#
# "écriture de connexion_utilisateur en base..." ne s'affiche JAMAIS --
# le corps de la coroutine n'a tout simplement pas commencé à s'exécuter.
Le réflexe du numéroThis issue's reflex

Un RuntimeWarning: coroutine was never awaited n'est jamais du bruit à ignorer — c'est le signalement exact d'un morceau de code qui n'a jamais tourné.A RuntimeWarning: coroutine was never awaited is never noise to ignore — it's the exact report of a piece of code that never ran.

№ 02La surpriseThe surprise4 min

Deux oublis, deux silences différents — l'un ne démarre jamais, l'autre démarre puis peut disparaître.Two omissions, two different silences — one never starts, the other starts and can then vanish.

La surprise est qu'il existe deux façons distinctes de perdre une coroutine, et qu'elles ne se comportent pas pareil. Oublier await ou create_task tout court laisse la coroutine à l'état d'objet inerte : elle ne démarre jamais, et un RuntimeWarning le signale au moins une fois. Utiliser create_task sans garder de référence vers la Task créée est plus insidieux : la tâche démarre réellement, planifiée sur la boucle — mais comme rien ne la référence ailleurs que la boucle elle-même, elle devient une tâche orpheline, que le garbage collector peut détruire en plein milieu de son exécution, avant qu'elle n'ait fini. C'est le pendant Python de la goroutine qui fuit : une unité de concurrence lancée sans jamais être suivie jusqu'à sa fin.The surprise is that there are two distinct ways to lose a coroutine, and they don't behave the same. Forgetting await or create_task entirely leaves the coroutine as an inert object: it never starts, and a RuntimeWarning at least flags it once. Using create_task without keeping a reference to the created Task is more insidious: the task actually starts, scheduled on the loop — but since nothing references it besides the loop itself, it becomes an orphan task, which the garbage collector can destroy right in the middle of its execution, before it finishes. This is the Python counterpart of the leaking goroutine: a unit of concurrency launched without ever being tracked through to completion.

Un seul RuntimeWarning -- au moins un signal existeOne single RuntimeWarning -- at least a signal exists
import asyncio

async def envoyer_notification(utilisateur):
    await asyncio.sleep(0.5)
    print(f"notification envoyée à {utilisateur}")

async def traiter_commande(commande):
    print(f"commande {commande} traitée")
    envoyer_notification(commande.utilisateur)   # oublié : pas de await,
                                                    # pas de create_task
    # la coroutine créée ici n'a AUCUNE référence conservée --
    # elle est même éligible au garbage collector immédiatement

asyncio.run(traiter_commande(commande))
# "notification envoyée" ne s'affiche jamais. Un seul avertissement,
# facilement noyé, prévient que quelque chose a été oublié.
№ 03La mécaniqueThe mechanics5 min

La boucle d'événements ne garde qu'une référence faible vers chaque tâche — le reste, c'est au code de le faire.The event loop keeps only a weak reference to each task — the rest is the code's job.

asyncio.create_task enveloppe une coroutine dans un objet Task et la planifie immédiatement sur la boucle d'événements — jusque-là, rien à voir avec le cas silencieux du chapitre précédent. Mais la documentation officielle d'asyncio est explicite : la boucle elle-même ne conserve qu'une référence faible vers chaque tâche créée. Une référence faible n'empêche pas le garbage collector de détruire l'objet (mécanisme détaillé au n°25) — elle sert seulement à ce que la boucle puisse encore la retrouver si quelque chose d'autre la retient par ailleurs. Si aucune variable, aucune liste, aucun ensemble ne garde une référence forte vers cette Task, elle peut être collectée avant d'avoir terminé, quel que soit son état d'avancement.asyncio.create_task wraps a coroutine in a Task object and immediately schedules it on the event loop — so far, nothing like the silent case from the previous chapter. But asyncio's official documentation is explicit: the loop itself only keeps a weak reference to each task it creates. A weak reference doesn't prevent the garbage collector from destroying the object (the mechanism detailed in issue №25) — it only lets the loop still find the task if something else holds it elsewhere. If no variable, no list, no set keeps a strong reference to that Task, it can be collected before finishing, regardless of how far along it is.

Aucune référence forte après la création -- la tâche devient orphelineNo strong reference after creation -- the task becomes an orphan
# Documentation officielle d'asyncio, littéralement :
# "Save a reference to the result of this function, to avoid a task
#  disappearing mid-execution. The event loop only keeps weak
#  references to tasks. A task that isn't referenced elsewhere may
#  get garbage collected at any time, even before it's done."

import asyncio

async def arriere_plan():
    await asyncio.sleep(2)
    print("terminé")

async def main():
    # la boucle elle-même ne retient la tâche que par une référence
    # FAIBLE -- elle ne compte pas pour le garbage collector (n°25)
    asyncio.create_task(arriere_plan())
    await asyncio.sleep(0.1)
    # ici, plus AUCUNE variable Python ne référence la tâche --
    # elle devient éligible à la collecte, alors qu'elle tourne encore
Un ensemble de tâches en arrière-plan garde la référence forte requiseA set of background tasks keeps the required strong reference
import asyncio

taches_en_arriere_plan = set()   # référence FORTE, gardée explicitement

async def arriere_plan():
    await asyncio.sleep(2)
    print("terminé")

async def main():
    tache = asyncio.create_task(arriere_plan())
    taches_en_arriere_plan.add(tache)               # référence conservée
    tache.add_done_callback(taches_en_arriere_plan.discard)  # nettoyage
                                                               # une fois finie
    await asyncio.sleep(3)
    # la tâche a le temps de tourner jusqu'au bout -- le set la retient
    # tant qu'elle n'est pas terminée, le callback la retire ensuite
Bridge — n°25 en approcheBridge — issue №25 ahead

Ce chapitre a mentionné une référence faible sans encore expliquer ce qui distingue une référence forte, dans le mécanisme de comptage qui décide, au fond, quand un objet Python meurt réellement. C'est exactement la question que le prochain volume ouvre.This chapter mentioned a weak reference without yet explaining what sets a strong reference apart, in the counting mechanism that ultimately decides when a Python object actually dies. That's exactly the question the next volume opens.

№ 04Le piègeThe trap4 min

Un « fire and forget » qui retourne trop vite peut littéralement faire disparaître la tâche qu'il vient de lancer.A "fire and forget" that returns too quickly can literally make the task it just launched disappear.

Le piège concret : une fonction qui traite une requête crée une tâche d'arrière-plan — journaliser un événement, envoyer une métrique — puis retourne immédiatement sa réponse sans attendre cette tâche. C'est le style « fire and forget », légitime en soi. Le problème est que la variable locale contenant la Task disparaît à la fin de la fonction : plus rien, nulle part dans le code, ne la référence fortement. Sous faible charge, la tâche a souvent le temps de finir avant que le garbage collector ne passe — le bug reste invisible en développement. Sous forte charge en production, une fraction de ces tâches est détruite en plein vol, et les événements correspondants ne sont simplement jamais journalisés, sans qu'aucune erreur ne le signale.The concrete trap: a function handling a request creates a background task — logging an event, sending a metric — then immediately returns its response without waiting on that task. This is the 'fire and forget' style, legitimate on its own. The problem is that the local variable holding the Task disappears at the end of the function: nothing anywhere in the code strongly references it anymore. Under light load, the task usually has time to finish before the garbage collector runs — the bug stays invisible in development. Under heavy load in production, a fraction of those tasks gets destroyed mid-flight, and the corresponding events simply never get logged, with no error signaling it.

Bug invisible en dev, intermittent en production sous chargeBug invisible in dev, intermittent in production under load
import asyncio

async def journaliser_analytics(evenement):
    await asyncio.sleep(1)   # appel réseau vers un service d'analytics
    print(f"événement {evenement} journalisé")

async def gerer_requete(requete):
    reponse = construire_reponse(requete)
    asyncio.create_task(journaliser_analytics(requete.nom))   # "fire and forget"
    return reponse   # la fonction RETOURNE ici -- la Task locale créée
                      # au-dessus n'est référencée nulle part ailleurs

# gerer_requete() est appelée des milliers de fois par seconde.
# Chaque appel crée une Task orpheline. La plupart survivent assez
# longtemps pour finir -- mais sous charge, ou si le processus event
# loop tourne vite, certaines sont détruites avant d'avoir journalisé
# quoi que ce soit. Le bug est invisible en dev, intermittent en prod.
Le réflexe à retenirThe reflex to keep

asyncio.create_task ne suffit jamais à lui seul : soit garder une référence forte dans une structure vivante (un set de tâches en arrière-plan), soit utiliser asyncio.TaskGroup quand la fin de toutes les tâches peut être attendue avant de continuer.asyncio.create_task is never enough on its own: either keep a strong reference in a living structure (a set of background tasks), or use asyncio.TaskGroup when every task's completion can be awaited before moving on.

№ 05Bilan & éditoRecap & editorial2 min

Volume VIII en une tableVolume VIII in one table

№No.TitreTitleTensionTension
22Le GILThe GILThreads pour l'I/O, jamais pour le calcul (build standard) ; multiprocessing pour le vrai parallélismeThreads for I/O, never for computation (standard build); multiprocessing for real parallelism
23asyncio : un seul thread, coopératifasyncio: a single thread, cooperativeLa boucle d'événements ; await comme point de suspension ; l'appel bloquant qui gèle toutThe event loop; await as a suspension point; the blocking call that freezes everything
24La coroutine jamais attendueThe coroutine that's never awaitedcoro() sans await ne s'exécute jamais ; la tâche orpheline sans référence fortecoro() without await never runs; the orphan task with no strong reference
La concurrence en Python n'a jamais menti sur ses règles. Un seul thread, un GIL, une boucle coopérative — le silence des bugs vient toujours de ce qu'on a oublié de leur donner une référence.Python concurrency never lied about its rules. A single thread, a GIL, a cooperative loop — the silence of these bugs always comes from forgetting to give them a reference.
Prochain numéro — №25, ouverture du Volume IXNext issue — No. 25, opening Volume IX

Volume VIII s'est refermé sur une référence faible qui ne suffit pas à garder un objet en vie. Volume IX, le dernier de la série, pose la question depuis le début : qu'est-ce qui garde réellement un objet Python en vie ? Le №25 ouvre sur le comptage de références — refcount, libération immédiate, et le cycle que le ramasse-miettes doit briser à la main.Volume VIII closed on a weak reference that isn't enough to keep an object alive. Volume IX, the last in the series, asks the question from the start: what actually keeps a Python object alive? No. 25 opens with reference counting — refcount, immediate release, and the cycle the cyclic garbage collector has to break by hand.