Python Language
Collecte des ordures

Remarques

/* Break reference cycles by clearing the containers involved.  This is
 * tricky business as the lists can be changing and we don't know which
 * objects may be freed.  It is possible I screwed something up here.
 */
static void
delete_garbage(PyGC_Head *collectable, PyGC_Head *old)

class A(object):
    def __init__(self, b=None):
        self.b = b
 
    def __del__(self):
        print("We're deleting an instance of A containing:", self.b)
     
class B(object):
    def __init__(self, a=None):
        self.a = a
 
    def __del__(self):
        print("We're deleting an instance of B containing:", self.a)

/* list of uncollectable objects */
static PyObject *garbage = NULL;

Comptage de référence

La grande majorité de la gestion de la mémoire Python est gérée avec le comptage des références.

Chaque fois qu'un objet est référencé (par exemple, affecté à une variable), son compte de référence est automatiquement augmenté. Quand il est déréférencé (par exemple, la variable sort de la portée), son compte de référence est automatiquement diminué.

Lorsque le compteur de références atteint zéro, l'objet est immédiatement détruit et la mémoire est immédiatement libérée. Ainsi, dans la majorité des cas, le ramasse-miettes n'est même pas nécessaire.

>>> import gc; gc.disable()  # disable garbage collector
>>> class Track:
        def __init__(self):
            print("Initialized")
        def __del__(self):
            print("Destructed")
>>> def foo():
        Track()
        # destructed immediately since no longer has any references
        print("---")
        t = Track()
        # variable is referenced, so it's not destructed yet
        print("---")
        # variable is destructed when function exits
>>> foo()
Initialized
Destructed
---
Initialized
---
Destructed

Démontrer plus avant le concept de références:

>>> def bar():
        return Track()
>>> t = bar()
Initialized
>>> another_t = t  # assign another reference
>>> print("...")
...
>>> t = None          # not destructed yet - another_t still refers to it
>>> another_t = None  # final reference gone, object is destructed
Destructed

Garbage Collector pour les cycles de référence

La seule fois où le ramasse-miettes est nécessaire, c'est si vous avez un cycle de référence . L'exemple simple d'un cycle de référence est celui dans lequel A désigne B et B désigne A, tandis que rien d'autre ne fait référence à A ou B. Ni A ni B ne sont accessibles de n'importe où dans le programme, ils peuvent donc être détruits en toute sécurité. cependant, leurs comptages de référence sont 1 et ils ne peuvent donc pas être libérés par l'algorithme de comptage de référence seul.

>>> import gc; gc.disable()  # disable garbage collector
>>> class Track:
        def __init__(self):
            print("Initialized")
        def __del__(self):
            print("Destructed")
>>> A = Track()
Initialized
>>> B = Track()
Initialized
>>> A.other = B
>>> B.other = A
>>> del A; del B  # objects are not destructed due to reference cycle
>>> gc.collect()  # trigger collection
Destructed
Destructed
4

Un cycle de référence peut être arbitrairement long. Si A pointe vers B pointe vers C pointe sur ... pointe vers Z qui pointe sur A, alors ni A ni Z ne seront collectés, jusqu'à la phase de récupération de place:

>>> objs = [Track() for _ in range(10)]
Initialized
Initialized
Initialized
Initialized
Initialized
Initialized
Initialized
Initialized
Initialized
Initialized
>>> for i in range(len(objs)-1):
...     objs[i].other = objs[i + 1]
...
>>> objs[-1].other = objs[0]  # complete the cycle
>>> del objs                  # no one can refer to objs now - still not destructed
>>> gc.collect()
Destructed
Destructed
Destructed
Destructed
Destructed
Destructed
Destructed
Destructed
Destructed
Destructed
20

Effets de la commande del

Suppression d'un nom de variable de l'étendue à l'aide de del v ou suppression d'un objet d'une collection à l'aide de del v[item] ou del[i:j] ou suppression d'un attribut avec del v.name ou tout autre moyen de suppression de références un objet ne déclenche aucun appel de destructeur ni aucune mémoire libérée en soi. Les objets ne sont détruits que lorsque leur compte de référence atteint zéro.

>>> import gc
>>> gc.disable()  # disable garbage collector
>>> class Track:
        def __init__(self):
            print("Initialized")
        def __del__(self):
            print("Destructed")
>>> def bar():
    return Track()
>>> t = bar()
Initialized
>>> another_t = t  # assign another reference
>>> print("...")
...
>>> del t          # not destructed yet - another_t still refers to it
>>> del another_t  # final reference gone, object is destructed
Destructed

Réutilisation d'objets primitifs

Une chose intéressante à noter qui peut aider à optimiser vos applications est que les primitives sont en fait également recalculées sous le capot. Jetons un coup d'oeil aux chiffres; pour tous les entiers compris entre -5 et 256, Python réutilise toujours le même objet:

>>> import sys
>>> sys.getrefcount(1)
797
>>> a = 1
>>> b = 1
>>> sys.getrefcount(1)
799

Notez que le refcount augmente, ce qui signifie que a et b référencent le même objet sous-jacent lorsqu'ils font référence à la primitive 1 . Cependant, pour les nombres plus importants, Python ne réutilise pas réellement l'objet sous-jacent:

>>> a = 999999999
>>> sys.getrefcount(999999999)
3
>>> b = 999999999
>>> sys.getrefcount(999999999)
3

Étant donné que le refcount pour 999999999 ne change pas lors de l'affectation à a et b nous pouvons en déduire qu'ils font référence à deux objets sous-jacents différents, même s'ils se voient attribuer la même primitive.

Affichage du refcount d'un objet

>>> import sys
>>> a = object()
>>> sys.getrefcount(a)
2
>>> b = a
>>> sys.getrefcount(a)
3
>>> del b
>>> sys.getrefcount(a)
2

Désallouer des objets avec force

Vous pouvez forcer les objets de désaffectation même si leur refcount n'est pas 0 dans Python 2 et 3.

Les deux versions utilisent le module ctypes pour le faire.

AVERTISSEMENT: cela laissera faire votre environnement Python instable et enclin à s'écraser sans retraçage! L'utilisation de cette méthode peut également créer des problèmes de sécurité (très improbable). Déjà.

import ctypes
deallocated = 12345
ctypes.pythonapi._Py_Dealloc(ctypes.py_object(deallocated))

import ctypes, sys
deallocated = 12345
(ctypes.c_char * sys.getsizeof(deallocated)).from_address(id(deallocated))[:4] = '\x00' * 4

Après l'exécution, toute référence à l'objet maintenant désalloué entraînera un comportement ou un blocage indéfini de Python, sans trace. Il y avait probablement une raison pour laquelle le garbage collector n'a pas supprimé cet objet ...

Si vous désallouez None , vous obtenez un message spécial - Fatal Python error: deallocating None avant de planter.

Gestion de la récupération de place

Il existe deux approches pour influencer le nettoyage de la mémoire. Ils influencent la fréquence à laquelle le processus automatique est exécuté et l'autre déclenche manuellement un nettoyage.

Le garbage collector peut être manipulé en réglant les seuils de collecte qui affectent la fréquence d'exécution du collecteur. Python utilise un système de gestion de la mémoire basé sur la génération. Les nouveaux objets sont enregistrés dans la génération la plus récente - generation0 et avec chaque collection survivante, les objets sont promus aux générations plus anciennes. Après avoir atteint la dernière génération - la génération 2 , ils ne sont plus promus.

Les seuils peuvent être modifiés à l'aide de l'extrait suivant:

import gc
gc.set_threshold(1000, 100, 10) # Values are just for demonstration purpose

Le premier argument représente le seuil de collecte de génération0 . Chaque fois que le nombre d' allocations dépasse le nombre de désallocations de 1 000, le récupérateur de mémoire sera appelé.

Les générations les plus anciennes ne sont pas nettoyées à chaque exécution pour optimiser le processus. Les deuxième et troisième arguments sont facultatifs et contrôlent la fréquence de nettoyage des générations les plus anciennes. Si generation0 a été traité 100 fois sans nettoyage de la génération 1 , alors la génération 1 sera traitée. De même, les objets de génération 2 ne seront traités que lorsque ceux de génération 1 ont été nettoyés 10 fois sans toucher à la génération 2 .

Un exemple dans lequel la définition manuelle des seuils est bénéfique est lorsque le programme alloue un grand nombre de petits objets sans les désallouer, ce qui entraîne l'exécution trop fréquente du ramasse-miettes (chaque attribution d'objet generation0_threshold ). Bien que le collecteur soit assez rapide, lorsqu'il fonctionne sur un grand nombre d'objets, il pose un problème de performance. Quoi qu'il en soit, il n'y a pas de stratégie unique pour choisir les seuils et son utilisation est fiable.

Le déclenchement manuel d'une collection peut se faire comme dans l'extrait de code suivant:

import gc
gc.collect()

La récupération de place est automatiquement déclenchée en fonction du nombre d'allocations et de désallocations, et non de la mémoire consommée ou disponible. Par conséquent, lorsque vous travaillez avec des objets volumineux, la mémoire peut être épuisée avant le déclenchement du nettoyage automatisé. Cela fait un bon cas d'utilisation pour appeler manuellement le garbage collector.

Même si c'est possible, ce n'est pas une pratique encouragée. Eviter les fuites de mémoire est la meilleure option. Quoi qu'il en soit, dans les grands projets, la détection de la fuite de mémoire peut être une tâche ardue et le déclenchement manuel d'une récupération de place peut être utilisé comme solution rapide jusqu'au débogage ultérieur.

Pour les programmes de longue durée, le nettoyage de la mémoire peut être déclenché sur une base ponctuelle ou par événement. Un exemple pour le premier est un serveur Web qui déclenche une collecte après un nombre fixe de requêtes. Par la suite, un serveur Web qui déclenche un nettoyage de la mémoire lorsqu'un certain type de demande est reçu.

N'attendez pas que le ramasse-miettes nettoie

Le fait que le ramasse-miettes se nettoie ne signifie pas que vous devez attendre le nettoyage du cycle de nettoyage.

En particulier, vous ne devez pas attendre le nettoyage de la mémoire pour fermer les descripteurs de fichiers, les connexions à la base de données et les connexions réseau ouvertes.

par exemple:

Dans le code suivant, vous supposez que le fichier sera fermé lors du prochain cycle de récupération de la mémoire, si f était la dernière référence au fichier.

>>> f = open("test.txt")
>>> del f

Un moyen plus explicite de nettoyer est d'appeler f.close() . Vous pouvez le faire encore plus élégant, en utilisant l'instruction with , également appelée gestionnaire de contexte :

>>> with open("test.txt") as f:
...     pass
...     # do something with f
>>> #now the f object still exists, but it is closed

L'instruction with vous permet d'indenter votre code sous le fichier ouvert. Cela rend explicite et plus facile de voir combien de temps un fichier reste ouvert. Il ferme également toujours un fichier, même si une exception est déclenchée dans le bloc while .