Le ramasse-miettes (garbage collector) de Python

Gestion automatique de la mémoire en Python

En Python, vous n'avez pas besoin de gérer explicitement la mémoire (allouer et libérer de la mémoire) comme dans des langages comme C ou C++. Python utilise un mécanisme de *gestion automatique de la mémoire*.

Cela signifie que l'interpréteur Python s'occupe automatiquement d'allouer la mémoire nécessaire pour stocker les objets que vous créez (variables, listes, dictionnaires, instances de classes, etc.), et de libérer cette mémoire lorsque les objets ne sont plus utilisés.

Le composant principal de la gestion automatique de la mémoire en Python est le *ramasse-miettes* (garbage collector, ou GC en abrégé).

La gestion automatique de la mémoire simplifie grandement le développement en Python, car vous n'avez pas à vous soucier des détails de bas niveau de la gestion de la mémoire. Cela réduit le risque d'erreurs courantes dans d'autres langages, comme les fuites de mémoire (memory leaks) ou les accès à de la mémoire non allouée.

Comptage de références : la base du ramasse-miettes

Le mécanisme principal utilisé par le ramasse-miettes de Python (dans l'implémentation CPython) est le *comptage de références*.

Chaque objet en Python a un compteur de références, qui est un entier indiquant combien de références pointent vers cet objet. Une référence est un nom (variable, attribut, élément d'une liste, etc.) qui fait référence à l'objet.

Lorsqu'un objet est créé, son compteur de références est initialisé à 1.

• Lorsqu'une nouvelle référence à l'objet est créée (par exemple, lorsque vous affectez l'objet à une variable), le compteur de références est incrémenté.
• Lorsqu'une référence à l'objet est supprimée (par exemple, lorsque vous supprimez une variable avec `del`, ou lorsqu'une variable sort de sa portée), le compteur de références est décrémenté.

Lorsque le compteur de références d'un objet tombe à zéro, cela signifie qu'il n'y a plus aucune référence à cet objet, et donc qu'il n'est plus accessible. L'objet est alors immédiatement *désalloué* (sa mémoire est libérée).

Exemple :

import sys

x = [1, 2, 3]  # Crée une liste et une référence (x)
print(sys.getrefcount(x))  # Affiche le nombre de références (au moins 2, car la fonction getrefcount prend elle aussi une référence!)
y = x          # Crée une nouvelle référence (y) à la même liste
print(sys.getrefcount(x)) # Le compteur augmente
del x          # Supprime la référence x
print(sys.getrefcount(y)) # Le compteur diminue, mais n'est pas à 0.
del y          # Supprime la dernière référence : la liste est désallouée (le ramasse-miette entre en action)

Le comptage de références est un mécanisme simple et efficace pour gérer la mémoire, mais il a une limitation importante : il ne peut pas détecter les *cycles de références*.

Cycles de références : le problème

Un cycle de références se produit lorsque deux ou plusieurs objets se référencent mutuellement, créant une boucle. Même si aucune variable externe ne pointe vers ces objets, leur compteur de références ne tombera jamais à zéro, car ils se référencent les uns les autres.

Exemple :

# Crée un cycle de références
l1 = []
l2 = []
l1.append(l2)
l2.append(l1)

# l1 et l2 se référencent mutuellement
# Même si on supprime les noms l1 et l2, les objets restent en mémoire
del l1
del l2

# Le ramasse-miettes basé sur le comptage de références ne peut pas
# libérer la mémoire occupée par ces objets.

Dans cet exemple, même après avoir supprimé les variables `l1` et `l2`, les deux listes existent toujours en mémoire, car elles se référencent mutuellement. Leur compteur de références est de 1, pas de 0.

Les cycles de références sont un problème, car ils peuvent entraîner des fuites de mémoire : la mémoire occupée par les objets cycliques n'est jamais libérée, même s'ils ne sont plus utilisés.

Détection des cycles : le ramasse-miettes cyclique

Pour résoudre le problème des cycles de références, Python utilise un *ramasse-miettes cyclique* (cycle collector) en plus du comptage de références.

Le ramasse-miettes cyclique est un algorithme plus complexe qui est capable de détecter et de collecter les objets inaccessibles qui font partie de cycles de références.

Le ramasse-miettes cyclique ne s'exécute pas en permanence. Il est déclenché périodiquement, ou lorsqu'un certain seuil est atteint (nombre d'allocations d'objets, par exemple).

Le ramasse-miettes cyclique parcourt les objets en mémoire, recherche les cycles de références, et libère la mémoire occupée par les objets inaccessibles qui font partie de ces cycles.

Vous n'avez généralement pas besoin d'interagir directement avec le ramasse-miettes cyclique, mais il est important de savoir qu'il existe et qu'il gère les cycles de références.

Le module gc : interagir avec le ramasse-miettes (avancé)

Le module `gc` de la bibliothèque standard Python fournit une interface pour interagir avec le ramasse-miettes (principalement le ramasse-miettes cyclique).

Vous utiliserez rarement le module `gc` directement, mais il peut être utile dans certains cas avancés, pour :

• Désactiver ou activer le ramasse-miettes cyclique (`gc.disable()`, `gc.enable()`). C'est généralement déconseillé, sauf pour des raisons de débogage ou de performance très spécifiques.
• Forcer une collecte immédiate (`gc.collect()`).
• Obtenir des informations sur les objets collectés (`gc.get_objects()`, `gc.get_referrers()`, `gc.get_referents()`).
• Définir des seuils pour le déclenchement du ramasse-miettes (`gc.set_threshold()`).
• Déboguer les fuites de mémoire.

Exemple (forcer une collecte et afficher le nombre d'objets inaccessibles) :

import gc

# Créer un cycle de références
l1 = []
l2 = []
l1.append(l2)
l2.append(l1)
del l1
del l2

# Forcer une collecte
n = gc.collect()
print("Nombre d'objets inaccessibles collectés :", n)

Dans la plupart des cas, vous pouvez laisser Python gérer la mémoire automatiquement. Le module `gc` est principalement utile pour des cas d'utilisation avancés ou pour le débogage de problèmes de mémoire.

Bonnes pratiques

Quelques conseils pour conclure sur la gestion de la mémoire :

• Faites confiance au ramasse-miette : Dans la très grande majorité des cas, laissez la gestion de la mémoire se faire. N'essayez pas d'optimiser prématurément.
• Evitez les cycles de référence si possible : Même si le ramasse-miettes cyclique gère les cycles, les éviter peut améliorer les performances.
• Utilisez `with` : Pour les fichiers et autres ressources, `with` assure la libération.
• Utilisez des structures de données adaptées : Certaines structures de données consomment moins que d'autre (les tuples sont plus légers que les listes, les générateurs sont plus légers que les listes, etc.)
• Si vous avez des problèmes de mémoire : Utilisez des outils de profilage de mémoire pour identifier les fuites ou les objets qui consomment trop de mémoire. Le module `gc`, ou des librairies tierces comme `memory_profiler` peuvent aider.