Python Language
Garbage Collection

Opmerkingen

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

Referentietelling

Het overgrote deel van Python-geheugenbeheer wordt afgehandeld met referentietellingen.

Telkens wanneer naar een object wordt verwezen (bijvoorbeeld toegewezen aan een variabele), wordt het referentietelling automatisch verhoogd. Wanneer er naar een verwijzing wordt verwezen (variabele valt bijvoorbeeld buiten het bereik), wordt het referentietelling automatisch verlaagd.

Wanneer de referentietelling nul bereikt, wordt het object onmiddellijk vernietigd en wordt het geheugen onmiddellijk vrijgegeven. In de meeste gevallen is de vuilnisman dus niet eens nodig.

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

Om het concept van referenties verder te demonstreren:

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

De enige keer dat de vuilnisman nodig is, is als u een referentiecyclus heeft . Het eenvoudige voorbeeld van een referentiecyclus is er een waarin A verwijst naar B en B verwijst naar A, terwijl niets anders verwijst naar A of B. Noch A of B zijn overal toegankelijk in het programma, zodat ze veilig kunnen worden vernietigd, maar hun referentietellingen zijn 1 en dus kunnen ze niet worden bevrijd door het referentietellingsalgoritme alleen.

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

Een referentiecyclus kan willekeurig lang zijn. Als A naar B wijst naar C naar ... wijst naar Z die naar A wijst, dan worden geen van beide A tot en met Z verzameld tot de fase van de afvalinzameling:

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

Effecten van de opdracht del

Een variabelenaam verwijderen uit het bereik met del v , of een object verwijderen uit een verzameling met del v[item] of del[i:j] , of een attribuut verwijderen met del v.name , of een andere manier om verwijzingen naar te verwijderen een object, geen destructor oproepen activeren of geheugen bevrijd op zich. Objecten worden alleen vernietigd wanneer hun referentietelling nul bereikt.

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

Hergebruik van primitieve objecten

Een interessant ding om op te merken dat kan helpen uw toepassingen te optimaliseren, is dat primitieven ook opnieuw worden getild onder de motorkap. Laten we eens naar getallen kijken; voor alle gehele getallen tussen -5 en 256, gebruikt Python altijd hetzelfde object:

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

Merk op dat de refcount toeneemt, wat betekent dat a en b hetzelfde onderliggende object verwijzen als ze naar de 1 primitieve verwijzen. Voor grotere aantallen hergebruikt Python het onderliggende object echter niet:

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

Omdat de refcount voor 999999999 niet verandert wanneer toe te wijzen aan a en b kunnen we afleiden dat ze verwijzen naar twee verschillende onderliggende objecten, hoewel ze allebei hetzelfde primitieve toegewezen.

De refcount van een object bekijken

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

Objecten krachtig dealloceren

Je kunt deallocatie van objecten forceren, zelfs als hun refcount niet 0 is in zowel Python 2 als 3.

Beide versies gebruiken hiervoor de module ctypes .

WAARSCHUWING: als u dit doet , blijft uw Python-omgeving onstabiel en kan het crashen zonder traceback! Het gebruik van deze methode kan ook beveiligingsproblemen veroorzaken (vrij onwaarschijnlijk). Alleen objecten dealloceren waarvan u zeker weet dat u er nooit meer naar zult verwijzen. Ooit.

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

Na het uitvoeren zal elke verwijzing naar het nu niet-toegewezen object ervoor zorgen dat Python ofwel ongedefinieerd gedrag produceert of crasht - zonder een traceback. Er was waarschijnlijk een reden waarom de vuilnisman dat object niet had verwijderd ...

Als je None dealloceert, krijg je een speciaal bericht - Fatal Python error: deallocating None voordat je crasht.

Afvalinzameling beheren

Er zijn twee benaderingen om te beïnvloeden wanneer een geheugenopruiming wordt uitgevoerd. Ze beïnvloeden hoe vaak het automatische proces wordt uitgevoerd en de andere handmatig een opschoning in gang zet.

De vuilnisman kan worden gemanipuleerd door de inzameldrempels af te stemmen die van invloed zijn op de frequentie waarmee de collector werkt. Python maakt gebruik van een op generatie gebaseerd geheugenbeheersysteem. Nieuwe objecten worden opgeslagen in de nieuwste generatie - generatie0 en bij elke overgebleven collectie worden objecten gepromoveerd tot oudere generaties. Na het bereiken van de laatste generatie - generatie2 , worden ze niet langer gepromoot.

De drempels kunnen worden gewijzigd met behulp van het volgende fragment:

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

Het eerste argument vertegenwoordigt de drempel voor het verzamelen van generatie0 . Elke keer als het aantal toewijzingen groter dan het aantal deallocations met 1000 de garbage collector zal worden genoemd.

De oudere generaties worden niet bij elke run schoongemaakt om het proces te optimaliseren. De tweede en derde argumenten zijn optioneel en bepalen hoe vaak de oudere generaties worden opgeschoond. Als generatie0 100 keer is verwerkt zonder generatie 1 op te schonen, wordt generatie 1 verwerkt. Op dezelfde manier worden objecten in generatie 2 alleen verwerkt wanneer degene in generatie1 10 keer werden opgeschoond zonder generatie2 aan te raken.

Een voorbeeld waarbij het handmatig instellen van de drempels nuttig is, is wanneer het programma veel kleine objecten toewijst zonder ze te dealloceren, wat ertoe leidt dat de vuilnisman te vaak wordt uitgevoerd (toewijzingen van elke generatie 0_threshold- objecten). Hoewel de verzamelaar behoorlijk snel is, levert het een enorm probleem op wanneer het op een groot aantal objecten draait. Hoe dan ook, er is geen one size fits all-strategie voor het kiezen van de drempels en het is use case betrouwbaar.

Handmatig een verzameling activeren kan als volgt in het volgende fragment:

import gc
gc.collect()

De afvalinzameling wordt automatisch geactiveerd op basis van het aantal toewijzingen en deallocaties, niet op basis van het verbruikte of beschikbare geheugen. Als u met grote objecten werkt, kan het geheugen daarom uitgeput raken voordat de automatische opschoning wordt geactiveerd. Dit is een goed gebruik om de vuilnisman handmatig te bellen.

Hoewel het mogelijk is, is het geen aangemoedigde oefening. Geheugenlekken voorkomen is de beste optie. Hoe dan ook, in grote projecten kan het detecteren van geheugenlekken een zware taak zijn en kan het handmatig activeren van een afvalinzameling worden gebruikt als een snelle oplossing tot verdere foutopsporing.

Voor langlopende programma's kan de afvalinzameling worden geactiveerd op basis van tijd of op basis van gebeurtenissen. Een voorbeeld voor de eerste is een webserver die een verzameling activeert na een vast aantal aanvragen. Voor de laatste, een webserver die een afvalinzameling activeert wanneer een bepaald type aanvraag wordt ontvangen.

Wacht niet tot de afvalinzameling is opgeruimd

Het feit dat de afvalinzameling zal opruimen, betekent niet dat je moet wachten tot de afvalinzamelingcyclus is opgeruimd.

In het bijzonder moet u niet wachten tot garbage collection de bestandshandvatten, databaseverbindingen en open netwerkverbindingen sluit.

bijvoorbeeld:

In de volgende code gaat u ervan uit dat het bestand wordt gesloten bij de volgende afvalinzamelcyclus, als f de laatste verwijzing naar het bestand was.

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

Een meer expliciete manier om op te ruimen is door f.close() aan te roepen. Je kunt het nog eleganter doen, dat wil zeggen door de instructie with te gebruiken, ook wel de contextmanager genoemd :

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

Met de instructie with kunt u uw code onder het geopende bestand laten inspringen. Dit maakt het expliciet en gemakkelijker om te zien hoe lang een bestand open blijft. Het sluit ook altijd een bestand, zelfs als er een uitzondering wordt gemaakt in het while blok.