Kaip veikia atminties valdymas ir šiukšlių surinkimas .NET?

Question

Accepted Answer

.NET automatiškai valdo atmintį naudodamas **šiukšlių surinkiklį (GC)** — jis išdėsto objektus valdomoje krupoje ir atgauna tuos, kurie nėra pasiekiami, todėl jūs neturite rankiniu būdu atlaisvinti atminties. Supratimas apie GC (generacijinį, stack/heap padalijimą ir `IDisposable`) yra svarbus dėl našumo ir korektiškai.

## Stack ir heap

```text
Stack → value types (locals), method frames; fast, automatically freed when scope ends.
Heap  → reference type objects (class instances); managed by the GC.
A reference variable lives on the stack but points to its object on the heap.
```

## Generacinis šiukšlių surinkiklis

```text
The GC divides the heap into GENERATIONS (based on the "most objects die young" idea):
  Gen 0 → newest objects; collected FREQUENTLY (fast, cheap)
  Gen 1 → survived one collection
  Gen 2 → long-lived objects; collected RARELY (expensive)
  (+ Large Object Heap for big objects)
→ Collecting young generations often + old ones rarely makes the GC efficient.
```

GC pažymi pasiekiamus objektus (iš šaknų: stack, statiniai laukai) ir atgauna likusius. Jis **generacinis** — dauguma objektų greitai miršta, todėl Gen 0 surenkama dažnai ir pigu, o ilgaamžiai objektai Gen 2 surenkavami retai.

## IDisposable ir using — nevaldomų išteklių naudojimui

```csharp
// the GC handles MANAGED memory, but NOT unmanaged resources (files, connections, handles)
// → implement IDisposable and use `using` for deterministic cleanup
using (var file = new StreamReader("data.txt"))
{
    // use file
}   // file.Dispose() called automatically — releases the file handle NOW
```

GC atlaisvina valdomą atmintį, bet **nevaldomi ištekliai** (failų deskriptoriai, DB ryšiai, lizdai) reikalingi aiškaus valymo per **`IDisposable`/`Dispose()`** — `using` sakinys tai garantuoja deterministiškai (jūs nelaukiate GC).

## Atminties nuotėkiai vis dar įvyksta

```text
The GC frees only UNREACHABLE objects. "Leaks" come from lingering references:
  ✗ static collections/caches that only grow
  ✗ un-unsubscribed event handlers (the publisher keeps subscribers alive!)
  ✗ long-lived objects holding references to short-lived ones
```

## Kodėl tai svarbu

Supratimas apie .NET atminties valdymą ir šiukšlių surinkimą yra vertinga aukšto lygio žinios, skaitant veiksmingą, teisingą C# — nors GC jus atlaisvina nuo rankinio atminties valdymo (didelis produktyvumo ir saugumo privalumas, pašalinantis rankinį `free` ir paliktas žymutes), supratimas *kaip* tai veikia yra svarbus našumui jautriausiems programėliams ir subtilių klaidų vengimui.

Žinojimas apie **generacinį GC** (Gen 0 renkami dažnai ir pigu, Gen 2 retai bet brangiai, remiantis stebėjimu, kad dauguma objektų miršta jaunus), padeda jums samprotauti apie išdėstymo modelius ir GC spaudimą (mažinant išdėstymus, ypač trumpaamžių objektų, sumažina GC išlaidas).

**Stack ir heap** skirumas (reikšmės tipai stack'e, nuorodžių objektai heap'e) susijęs su reikšmės/nuorodžio tipo modeliu.

Kritiškai, supratimas apie **`IDisposable`/`Dispose()` ir `using` sakinį** yra esminis ir praktinis: GC valdo *atmintį*, bet ne *nevaldomus išteklius* (failų deskriptoriai, duomenų bazės ryšiai, lizdai), kurie reikalingi deterministinio valymo per `using` — nepavykus juos atlaisvinti, atsiranda išteklių nuotėkiai (bendra tikra klaida).

Tolygiai svarbu atpažinti, kad **atminties nuotėkiai vis dar įvyksta** nepaisant GC, dėl lingvojančių nuorodų (augančios statinės talpyklos, neprenumeruoti įvykių procesoriai, kurie laiko užsisako gyvas — klasikinis C# nuotėkis).

Supratimas apie GC generacinį modelį, išteklių šalinimo modelį (`IDisposable`/`using`) ir nuotėkių priežastis yra svarbus norint parašyti veiksmingą, nuotėkio neturinčią C#, ypač ilgai veikiančiose programose — todėl tai vertinga žinios, kurios išskiria programuotojus, galintys kurti efektyvias, teisingas .NET programas, ir yra dažnas aukšto lygio pokalbio tema.