Python Language
Müllsammlung

Bemerkungen

/* 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;

Referenzzählung

Die überwiegende Mehrheit der Python-Speicherverwaltung wird mit Referenzzählung ausgeführt.

Jedes Mal, wenn ein Objekt referenziert wird (z. B. einer Variablen zugewiesen) wird der Referenzzähler automatisch erhöht. Wenn dereferenziert wird (z. B. die Variable verlässt den Gültigkeitsbereich), wird die Referenzanzahl automatisch verringert.

Wenn der Referenzzähler Null erreicht, wird das Objekt sofort zerstört und der Speicher wird sofort freigegeben. In der Mehrzahl der Fälle wird der Müllsammler also nicht benötigt.

>>> 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

Um das Konzept der Referenzen weiter zu demonstrieren:

>>> 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

Speicherbereiniger für Referenzzyklen

Der Garbage Collector wird nur benötigt, wenn Sie einen Referenzzyklus haben . Das einfache Beispiel eines Referenzzyklus ist einer, in dem A sich auf B bezieht und B sich auf A bezieht, während sich nichts anderes auf A oder B bezieht. Ihre Referenzzählung ist jedoch 1 und kann daher nicht allein durch den Referenzzählalgorithmus freigegeben werden.

>>> 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

Ein Referenzzyklus kann beliebig lang sein. Wenn A auf B zeigt, zeigt B auf C, zeigt auf ..., zeigt auf Z, was auf A zeigt, dann werden bis zur Speicherbereinigungsphase weder A bis Z gesammelt.

>>> 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

Auswirkungen des Befehls del

Entfernen eines Variablennamens aus dem Gültigkeitsbereich mit del v oder Entfernen eines Objekts aus einer Auflistung mit del v[item] oder del[i:j] oder Entfernen eines Attributs mit del v.name oder einer anderen Möglichkeit zum Entfernen von Verweisen auf ein Objekt, löst keine destructor Anrufe oder jeder Speicher in sich selbst befreit. Objekte werden nur zerstört, wenn ihre Referenzzählung null erreicht.

>>> 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

Wiederverwendung von primitiven Objekten

Eine interessante Sache, die zur Optimierung Ihrer Anwendungen beitragen kann, ist, dass Primitive auch unter der Haube neu gezählt werden. Schauen wir uns die Zahlen an. Für alle Ganzzahlen zwischen -5 und 256 verwendet Python immer dasselbe Objekt:

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

Beachten Sie, dass der Refcount zunimmt, was bedeutet, dass a und b auf dasselbe zugrunde liegende Objekt verweisen, wenn sie sich auf das Primitiv 1 beziehen. Bei größeren Zahlen verwendet Python das zugrunde liegende Objekt jedoch nicht wieder:

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

Da sich der refcount für 999999999 nicht ändert, wenn er a und b zugewiesen wird, können wir daraus schließen, dass sie sich auf zwei verschiedene zugrunde liegende Objekte beziehen, obwohl ihnen beide das gleiche 999999999 zugewiesen ist.

Anzeige der Refcount eines Objekts

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

Objekte zwangsweise freigeben

Sie können die Freigabe von Objekten erzwingen, auch wenn ihr Refcount in Python 2 und 3 nicht 0 ist.

Beide Versionen verwenden dazu das Modul ctypes .

WARNUNG: Wenn Sie dies tun, wird Ihre Python-Umgebung instabil und zum Absturz neigen, ohne dass ein Traceback erforderlich ist! Die Verwendung dieser Methode kann auch zu Sicherheitsproblemen führen (ziemlich unwahrscheinlich). Heben Sie nur Objekte auf, von denen Sie sicher sind, dass Sie sie nie wieder referenzieren. Je.

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

Nach dem Ausführen führt jeder Verweis auf das jetzt freigegebene Objekt dazu, dass Python entweder undefiniertes Verhalten erzeugt oder abstürzt - ohne Traceback. Es gab wahrscheinlich einen Grund, warum der Müllsammler das Objekt nicht entfernt hat ...

Wenn Sie None Zuordnung None , wird eine spezielle Meldung Fatal Python error: deallocating None - Fatal Python error: deallocating None vor dem Absturz freigeben.

Verwalten der Speicherbereinigung

Es gibt zwei Ansätze, um zu beeinflussen, wann eine Speicherbereinigung durchgeführt wird. Sie beeinflussen, wie oft der automatische Prozess durchgeführt wird und der andere Prozess manuell eine Bereinigung auslöst.

Der Speicherbereiniger kann manipuliert werden, indem die Sammelschwellen eingestellt werden, die die Frequenz beeinflussen, mit der der Kollektor abläuft. Python verwendet ein generationsbasiertes Speicherverwaltungssystem. Neue Objekte werden in der neuesten Generation - Generation 0 gespeichert, und mit jeder erhaltenen Sammlung werden Objekte zu älteren Generationen befördert. Nach Erreichen der letzten Generation - Generation2 werden sie nicht mehr befördert.

Die Schwellenwerte können mit dem folgenden Snippet geändert werden:

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

Das erste Argument repräsentiert den Schwellenwert für das Sammeln der Generierung0 . Jedes Mal, wenn die Anzahl der Zuweisungen die Anzahl der Aufhebungen um 1000 überschreitet, wird der Garbage Collection aufgerufen.

Die älteren Generationen werden nicht bei jedem Durchlauf bereinigt, um den Prozess zu optimieren. Das zweite und das dritte Argument sind optional und steuern, wie oft ältere Generationen gereinigt werden. Wenn die Generierung 0 100 Mal ohne Bereinigung der Generierung1 verarbeitet wurde , wird die Generierung1 verarbeitet. In ähnlicher Weise werden die Objekte in generation2 nur verarbeitet werden , wenn die , die in generation1 10 mal gereinigt wurden ohne generation2 zu berühren.

Eine manuelle Einstellung der Schwellenwerte ist von Vorteil, wenn das Programm viele kleine Objekte zuweist, ohne sie aufzuheben, was dazu führt, dass der Garbage Collector zu oft ausgeführt wird (jede Objektzuordnung der Generation 0_Threshold). Obwohl der Collector ziemlich schnell ist, stellt er bei einer großen Anzahl von Objekten ein Leistungsproblem dar. Wie auch immer, es gibt keine einheitliche Strategie für die Auswahl der Schwellenwerte und die Zuverlässigkeit des Anwendungsfalls.

Das manuelle Auslösen einer Sammlung kann wie im folgenden Snippet durchgeführt werden:

import gc
gc.collect()

Die Speicherbereinigung wird automatisch basierend auf der Anzahl der Zuweisungen und Aufhebungen ausgelöst, nicht auf dem verbrauchten oder verfügbaren Speicher. Wenn Sie mit großen Objekten arbeiten, kann der Speicher erschöpft sein, bevor die automatische Bereinigung ausgelöst wird. Dies ist ein guter Anwendungsfall für das manuelle Aufrufen des Speicherbereinigers.

Obwohl es möglich ist, ist es keine ermutigte Praxis. Die Vermeidung von Speicherverlusten ist die beste Option. In großen Projekten kann das Erkennen des Speicherverlusts jedoch eine schwierige Aufgabe sein, und das manuelle Auslösen einer Speicherbereinigung kann als schnelle Lösung bis zum weiteren Debugging verwendet werden.

Bei lang laufenden Programmen kann die Speicherbereinigung nach Zeit oder Ereignis ausgelöst werden. Ein Beispiel für den ersten ist ein Webserver, der nach einer festgelegten Anzahl von Anforderungen eine Sammlung auslöst. Für letzteren einen Webserver, der eine Garbage Collection auslöst, wenn ein bestimmter Anforderungstyp empfangen wird.

Warten Sie nicht, bis die Müllsammlung aufgeräumt ist

Die Tatsache, dass die Speicherbereinigung aufgeräumt wird, bedeutet nicht, dass Sie warten müssen, bis der Speicherbereinigungszyklus aufgeräumt ist.

Insbesondere sollten Sie nicht warten, bis die Garbage Collection Dateihandles, Datenbankverbindungen und Netzwerkverbindungen geschlossen hat.

zum Beispiel:

Im folgenden Code wird davon ausgegangen, dass die Datei beim nächsten Garbage Collection-Zyklus geschlossen wird, wenn f der letzte Verweis auf die Datei war.

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

Eine explizitere Methode zum Bereinigen ist das Aufrufen von f.close() . Sie können es noch eleganter machen, indem Sie die with Anweisung verwenden, die auch als Kontextmanager bezeichnet wird :

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

Mit der with Anweisung können Sie Ihren Code unter der geöffneten Datei einrücken. Dies macht es explizit und einfacher zu sehen, wie lange eine Datei geöffnet bleibt. Es schließt auch immer eine Datei, auch wenn im while Block eine Ausnahme ausgelöst wird.