Comptage de références dans le mécanisme de récupération de place Python

La méthode magique __del__ en Python, également connue sous le nom de finaliseur d'objet, est une méthode qui est appelée juste avant que l'objet ne soit sur le point d'être supprimé de la mémoire. Cela ne fait pas réellement le travail de supprimer l’objet de la mémoire, nous verrons comment cela se produit plus tard. Au lieu de cela, cette méthode est utilisée pour effectuer tout nettoyage nécessaire avant la suppression de l’objet. Par exemple, fermez tous les fichiers ouverts lors de la création de l'objet.

Dans cette section, nous utiliserons la classe suivante comme exemple.

class MyNameClass:
def __init__(self, name):
self.name = name

def __del__(self):
print(f"Deleting {self.name}!")

Dans l'exemple ci-dessus, nous avons défini notre classe pour accepter un nom en entrée lors de l'initialisation, et lorsque le finaliseur est appelé, il nous le fera savoir en imprimant le nom de l'instance concernée. De cette façon, nous pouvons savoir quels objets ont été supprimés de la mémoire et quand.

Alors, quand CPython décide-t-il de supprimer un objet de la mémoire ? Cela peut se produire de deux manières (à partir de CPython 3.10) : le comptage de références et le garbage collection.

Comptage de références

Si nous avons un pointeur vers un objet en Python, c'est une référence à cet objet. Pour un objet a donné, CPython garde une trace du nombre d'autres éléments pointant vers un . Si ce compteur atteint zéro, vous pouvez supprimer l'objet de la mémoire en toute sécurité car rien d'autre ne l'utilise. Regardons un exemple.

>>> Harward = MyNameClass("Harward")
>>> del Harward
Deleting Harward!
>>>

Ici, nous créons un nouvel objet (MyNamedClass("Harward")) et créons un pointeur vers lui (Harward =). Ensuite, lorsque nous supprimons Harwade, nous supprimons cette référence et l'instance MyNamedClass a désormais un nombre de références de 0. Ainsi, CPython décide de le supprimer de la mémoire - et, juste avant de le faire, sa méthode __del__ est appelée, affichant le message que nous avons vu ci-dessus.

Si nous créons plusieurs références à un objet, nous devrons toutes nous en débarrasser pour que l'objet soit supprimé.

>>> bob = MyNameClass("Bob")
>>> bob_two = bob # creating a new pointer to the same object
>>> del bob # this doesn't cause the object to be removed...
>>> del bob_two # ... but this does
Deleting Bob!

Bien sûr, nos instances MyNamedClass peuvent elles-mêmes contenir des pointeurs - ce sont des objets Python arbitraires après tout, et nous pouvons leur ajouter toutes les propriétés que nous aimons. Regardons un exemple.

>>> jane = MyNamedClass("Jane")
>>> bob = MyNamedClass("Bob")
>>> jane.friend = bob # now the "Jane" object contains a pointer to the "Bob" object...
>>> bob.friend = jane

Ce que nous avons fait dans l'extrait de code ci-dessus est de définir des références circulaires. Un objet nommé Jane contient un pointeur vers un objet nommé Bob, et vice versa. Les choses deviennent intéressantes lorsque nous faisons ce qui suit.

>>> del jane
>>> del bob

Nous avons maintenant supprimé le pointeur de l'espace de noms vers l'objet. Désormais, nous n'avons plus du tout accès à ces objets MyNameClass - mais nous ne recevons pas de message imprimé nous indiquant qu'ils sont sur le point d'être supprimés. En effet, ces objets ont toujours des références, contenues les unes dans les autres, donc leur nombre de références n'est pas 0 .

Ce que nous avons créé ici est un isolat de boucle ; dans cette structure, chaque objet a au moins une référence dans la boucle, le gardant vivant, mais tous les objets de la boucle ne sont pas accessibles depuis l'espace de noms.

Performance intuitive de l'isolation de boucle

Ce qui suit est la performance intuitive lorsque nous créons une isolation de boucle.

Tout d'abord, nous créons deux objets, chacun avec un nom dans l'espace de noms.

Ensuite, nous connectons nos deux objets en ajoutant un pointeur sur chaque objet.

Enfin, nous supprimons les pointeurs de l'espace de noms en supprimant les noms d'origine des deux objets. À ce stade, les deux objets ne sont pas accessibles depuis l'espace de noms, mais chaque objet contient un pointeur vers l'autre objet, donc leur nombre de références n'est pas nul.

Donc, évidemment, le comptage de références à lui seul ne suffit pas à garder la mémoire de travail d'exécution exempte d'objets inutiles et non recyclables. C'est là que le garbage collector de CPython entre en jeu.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!