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.