C# / .NET Kompendium PLEN
.NET / C# / Pamięć i wątki

Zarządzanie pamięcią w .NET - Garbage Collector

Generational Garbage Collector - fundamentalna architektura

.NET GC opiera się na obserwacji: większość obiektów żyje krótko (zmienne lokalne, tymczasowe DTO), a mniejszość żyje długo (Singletony, statyczne cache). GC dzieli stertę na generacje, optymalizując pod tę obserwację.

Gen 0 (młode obiekty)     → Gen 1 (przetrwały jedno GC)  → Gen 2 (długo żyjące)
Zbierane BARDZO często     Zbierane rzadziej                Zbierane najrzadziej
var order = new Order(); // trafia do Gen 0

Każdy nowo utworzony obiekt referencyjny trafia do Gen 0. Gdy Gen 0 się zapełni, GC wykonuje kolekcję Gen 0 - sprawdza, które obiekty są jeszcze "żywe" (mają aktywne referencje), usuwa resztę. Obiekty, które przetrwały kolekcję (bo wciąż są używane), są awansowane do Gen 1.

Dlaczego to jest wydajne: kolekcja Gen 0 jest bardzo szybka (mała ilość pamięci do przeskanowania, większość obiektów krótko żyjących i tak już jest "martwa"). Gdyby GC musiał zawsze skanować całą stertę, byłoby to drastycznie wolniejsze - stąd podział na generacje, gdzie rzadko trzeba skanować Gen 2 (bo mało się tam zmienia).

Mark-and-Sweep - jak faktycznie działa kolekcja

1. MARK (oznaczanie) - GC przechodzi od "korzeni" (root - zmienne lokalne na stosie, statyczne pola)
   i oznacza WSZYSTKIE obiekty osiągalne przez referencje jako "żywe"

2. SWEEP (zbieranie) - wszystko NIEOZNACZONE (nieosiągalne) jest uznawane za "śmieć" i pamięć jest zwalniana

3. COMPACT (kompaktowanie) - żywe obiekty są PRZESUWANE, żeby scalić wolną pamięć w jeden ciągły blok
   (eliminuje fragmentację)

To wyjaśnia, dlaczego cykliczne referencje NIE są problemem w .NET (w przeciwieństwie do prostego zliczania referencji, jak np. w starym COM) - jeśli dwa obiekty referencjonują się nawzajem, ale żaden korzeń nie prowadzi do nich, GC i tak je uzna za nieosiągalne i zwolni.

LOH (Large Object Heap) - specjalne traktowanie dużych obiektów

var bigArray = new byte[100_000]; // > 85 000 bajtów → trafia do LOH, NIE do Gen 0!

Obiekty większe niż ~85 KB trafiają do osobnej części stosu (Large Object Heap), która jest rzadko kompaktowana (przesuwanie dużych blików pamięci jest kosztowne) - to może prowadzić do fragmentacji LOH przy częstym tworzeniu/zwalnianiu dużych tablic, co jest częstym źródłem problemów wydajnościowych w aplikacjach przetwarzających duże dane (np. duże bufory przy przetwarzaniu plików).

.NET Framework vs .NET Core/.NET 5+ - różnice w GC

.NET Framework .NET Core / .NET 5+
Domyślny GC Workstation GC (jeden wątek) Server GC (wielowątkowy, domyślny w ASP.NET Core)
Konfigurowalność Ograniczona Bardziej szczegółowa (runtimeconfig.json, zmienne env)
Wydajność dla serwerów Słabsza pod dużym obciążeniem Znacznie lepsza (Server GC skaluje się z liczbą rdzeni CPU)
// runtimeconfig.json - konfiguracja GC w .NET Core/.NET 5+
{
  "configProperties": {
    "System.GC.Server": true,        // Server GC - wielowątkowy, lepszy dla wysokiego throughput
    "System.GC.Concurrent": true      // Background GC - część pracy w tle, mniej pauz
  }
}

Server GC tworzy osobny wątek GC per rdzeń CPU i osobną stertę per wątek - znacznie lepiej skaluje się na serwerach wielordzeniowych (typowe dla ASP.NET Core w produkcji), kosztem większego zużycia pamięci w porównaniu do Workstation GC (lepszego dla aplikacji desktopowych typu WPF, gdzie liczy się responsywność UI, nie maksymalny throughput).

IDisposable/using - zasoby NIEZARZĄDZANE, których GC nie widzi

To jest kluczowe rozróżnienie - GC zarządza pamięcią zarządzaną (.NET objects), ale nie wie o zasobach niezarządzanych (uchwyty plików, połączenia sieciowe, uchwyty systemu operacyjnego):

public class FileProcessor : IDisposable
{
    private readonly FileStream _stream; // zasób NIEZARZĄDZANY - uchwyt systemu operacyjnego

    public FileProcessor(string path) => _stream = File.OpenRead(path);

    public void Dispose() => _stream?.Dispose(); // MUSISZ zwolnić RĘCZNIE, GC tego nie zrobi za Ciebie
}
using (var processor = new FileProcessor("data.txt"))
{
    // ...
} // Dispose() wywołane AUTOMATYCZNIE na końcu bloku, nawet jeśli wyjątek zostanie rzucony

Dlaczego to jest ważne: bez using/Dispose(), uchwyt pliku zostaje otwarty, mimo że sam obiekt FileProcessor (pamięć zarządzana) może już dawno zostać zebrany przez GC - to prowadzi do wyczerpania zasobów systemu operacyjnego (np. "too many open files"), zupełnie niezależnie od tego, ile "wolnej pamięci RAM" masz.

Finalizery - "ostatnia linia obrony", ale kosztowna

public class FileProcessor : IDisposable
{
    private readonly FileStream _stream;

    ~FileProcessor() // finalizer - wywoływany przez GC, jeśli Dispose() NIE został wywołany
    {
        _stream?.Dispose();
    }

    public void Dispose()
    {
        _stream?.Dispose();
        GC.SuppressFinalize(this); // "nie musisz mnie finalizować, JUŻ się posprzątałem ręcznie"
    }
}

Obiekty z finalizerem wymagają dwóch przebiegów GC do pełnego zwolnienia (najpierw finalizer jest wykonywany, obiekt trafia do specjalnej kolejki, dopiero następna kolekcja faktycznie zwalnia pamięć) - stąd GC.SuppressFinalize(this) w Dispose() jest ważną optymalizacją, informującą GC, że finalizer jest niepotrzebny, bo zasoby już zostały zwolnione ręcznie.

Podsumowanie - praktyczne konsekwencje dla codziennego kodu

.NET GC dzieli stertę na generacje (Gen 0/1/2), optymalizując pod obserwację, że większość obiektów żyje krótko - kolekcja Gen 0 jest częsta i szybka, Gen 2 rzadka i kosztowna. Server GC (domyślny w ASP.NET Core) skaluje się wielowątkowo z liczbą rdzeni CPU, kosztem większego zużycia pamięci. Kluczowa praktyczna zasada: GC zarządza tylko pamięcią .NET - zasoby niezarządzane (pliki, sockets, połączenia do baz danych) wymagają jawnego Dispose()/using, niezależnie od tego, kiedy GC zwolni sam obiekt "kontenera" tych zasobów.

Postaw mi kawę