Kuinka Python hallinnoi muistia ja roskienkeruuta?

Question

Accepted Answer

Python hallinnoi muistia **automaattisesti** kahdella mekanismilla: **viittelaskennalla** (ensisijaisella menetelmällä) sekä **syklisellä roskienkerääjällä**, joka käsittelee viitesyklejä. Et koskaan vapauta muistia manuaalisesti, mutta ymmärtäminen siitä, miten se toimii, selittää muistinkäyttäytymisen ja vuodot.

## Viitelaskenta — ensisijainen mekanismi

```python
import sys

x = [1, 2, 3]        # the list object has refcount 1
y = x                 # refcount 2 (another name references it)
sys.getrefcount(x)    # shows the count (slightly higher due to the call itself)

del y                 # refcount 1
del x                 # refcount 0 → the object is FREED immediately
```

Jokainen objekti seuraa, kuinka monta viitettä osoittaa siihen. Kun luku putoaa **nollaan**, muisti vapautetaan **välittömästi**. Tämä on deterministinen ja nopea — objektit kuolevat heti kun mikään ei viittaa niihin.

## Ongelma: viitesyklit

```python
# reference counting alone can't free this:
a = {}
b = {}
a["b"] = b      # a references b
b["a"] = a      # b references a → they reference EACH OTHER
del a, b        # the names are gone, but the objects still reference each other
# → refcounts never reach 0 → they'd leak with refcounting alone
```

Kaksi objektia, jotka viittaavat toisiinsa, pitävät toistensa viitelaskennan nollaa yli suuremmalla arvolla, vaikka ne olisivat saavuttamattomia — sykli, jota puhdas viitelaskenta ei pysty keräämään.

## Syklinen roskienkerääjä

```python
import gc

# the generational GC periodically finds and frees unreachable CYCLES
gc.collect()        # manually trigger a collection
gc.get_count()      # objects tracked per generation
```

Pythonin täydentävä **generaatioittainen roskienkerääjä** havaitsee ja vapauttaa nämä saavuttamattomat syklit säännöllisesti. Se on *generaatioittainen* — uudempia objekteja tarkistetaan useammin (useimmat objektit kuolevat nuorina), mikä on tehokasta.

## Käytännölliset vaikutukset ja vuotojen lähteet

```text
✓ Most memory is reclaimed promptly via reference counting
⚠️ Leaks still happen from REACHABLE references that outlive their usefulness:
   - global caches/lists that only grow
   - objects held by long-lived closures or class attributes
   - registered callbacks/listeners never removed
```

Roskienkerääjä käsittelee syklejä, mutta se ei pysty vapauttamaan objekteja, joihin on vielä *saavutettavissa* — yleinen todellisen maailman "vuoto" on viitteille vahingossa elävät viitteet (esimerkiksi jatkuvasti kasvava globaali välimuisti).

## Muut yksityiskohdat

```text
- Small integers (-5..256) and short strings are CACHED/interned (shared, reused)
- CPython uses memory pools (pymalloc) for small objects (efficiency)
```

## Miksi sillä on merkitystä

Pythonin muistimallin ymmärtäminen — nopea viitelaskenta sekä syklinen roskienkerääjä — selittää todellisen käyttäytymisen: miksi objektit yleensä vapautetaan välittömästi, miksi viitesyklit tarvitsevat roskienkerääjää, ja kriittisesti miksi "muistivuodot" Pythonissa tulevat *saavutettavista* viitteistä (kasvavat välimuistit, pitkäikäiset sulkeumat, poistetut takaisinkynnykset) eikä unohduksista vapautuksista.

Tämä tieto on olennaista pitkäkestoisten palveluiden muistin kasvun diagnosoinnissa ja muistotietoisesti kirjoitetussa koodissa — tietäminen, että korjaus on yleensä viitteen katkaiseminen (välimuistin rajoittaminen, rekisteröintien siivous) eikä mitään, mitä roskienkerääjä voi tehdä puolestasi.