Scala for Backend Engineering & Functional Programming · Lekcja

Zarządzanie pamięcią i dostrajanie GC

Dogłębnie poznaj zarządzanie pamięcią JVM, garbage collection oraz techniki optymalizacji wykorzystania pamięci w Scali.

Lekcja 2 z 311 kroki

Zarządzanie pamięcią i dostrajanie GC to bezpłatna lekcja Scala for Backend Engineering & Functional Programming na CoddyKit. To lekcja 2 z 3. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Scala for Backend Engineering & Functional Programming, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Scala for Backend Engineering & Functional Programming zawiera 3 lekcji w sumie.

Wprowadzenie do pamięci JVM i GC

Witamy! W tej lekcji przyjrzymy się sposobowi zarządzania pamięcią przez Java Virtual Machine (JVM), co ma szczególne znaczenie w aplikacjach Scala.

Zrozumienie zarządzania pamięcią pomaga pisać wydajny i efektywny kod.
Omówimy Garbage Collection (GC), czyli automatyczny mechanizm zarządzania pamięcią w JVM.
Właściwe zarządzanie pamięcią zapobiega typowym problemom, takim jak błędy „out of memory”.

Sterta: przechowywanie obiektów

Sterta to największy obszar pamięci w JVM, w którym znajdują się wszystkie obiekty utworzone przez aplikację Scala. Obejmuje to instancje klas, tablice i większość struktur danych.

Sterta jest współdzielona przez wszystkie wątki aplikacji. Jej rozmiar bezpośrednio wpływa na liczbę obiektów, które program może jednocześnie przechowywać.

Stos a sterta: najważniejsze różnice

Podczas gdy sterta przechowuje obiekty, stos przechowuje zmienne lokalne (zwłaszcza typy proste i referencje do obiektów) oraz ramki wywołań metod. Każdy wątek ma własny stos.

sterta: Przechowuje obiekty, jest współdzielona i zarządzana przez GC.
Stos: Przechowuje wywołania metod i zmienne lokalne, jest przypisany do konkretnego wątku oraz zarządzany automatycznie podczas wchodzenia do metod i wychodzenia z nich.

Zrozumienie tej różnicy jest kluczowe podczas diagnozowania problemów z pamięcią.

Podstawy Garbage Collection

Garbage Collection (GC) to automatyczny proces JVM, który wyszukuje i odzyskuje pamięć zajmowaną przez obiekty, do których aplikacja nie ma już „osiągalnych” odwołań.

Zamiast ręcznie zwalniać pamięć, jak w C++, Scala (podobnie jak Java) korzysta z GC, aby zapobiegać wyciekom pamięci i upraszczać tworzenie oprogramowania. Podstawą jest mechanizm „mark and sweep”: oznaczanie osiągalnych obiektów, a następnie usuwanie pozostałych.

Generacyjny GC — wyjaśnienie

Większość współczesnych mechanizmów GC stosuje podejście generacyjne, dzieląc stertę na obszary zależnie od wieku obiektów:

Młoda generacja: Tutaj przydzielane są nowe obiekty. Większość z nich szybko przestaje być używana.
Stara generacja: Obiekty, które przetrwają wiele cykli GC w młodej generacji, są tutaj awansowane.

Pozwala to częściej i szybciej wykonywać GC w młodej generacji (Minor GC), a rzadziej i wolniej w starej generacji (Major GC).

Kolekcje Scala a pamięć

Nacisk, jaki Scala kładzie na niezmienność i programowanie funkcyjne, często oznacza tworzenie wielu krótkotrwałych obiektów, zwłaszcza podczas przekształcania kolekcji.

GC jest zoptymalizowany pod kątem takiego sposobu działania. Zobaczmy przykład tworzenia tymczasowych obiektów podczas przetwarzania listy:

object Main {
  def main(args: Array[String]): Unit = {
    println("Creating and transforming a list...")
    val originalList = (1 to 100000).toList // ~100k objects
    val transformedList = originalList.map(x => x * 2).filter(_ % 3 == 0)
    println(s"Transformed list size: ${transformedList.size}")
    // originalList and intermediate lists from map are now eligible for GC
    println("Intermediate objects are efficiently managed by GC.")
  }
}

Typowe scenariusze wycieków pamięci

Nawet przy użyciu GC mogą wystąpić wycieki pamięci, gdy obiekty są nieumyślnie utrzymywane przy życiu przez silne referencje. Typowe scenariusze w języku Scala obejmują:

Długowieczne pamięci podręczne: Przechowywanie obiektów bezterminowo w globalnej zmiennej mapie.
Domknięcia: Domknięcie (literał funkcji) przechwytujące duży obiekt, który żyje dłużej niż zamierzony zakres domknięcia.
Niezamknięte zasoby: Nieprawidłowe zamykanie uchwytów plików lub połączeń sieciowych.

Słabe referencje w pamięciach podręcznych

W przypadku pamięci podręcznych, w których GC powinien odzyskać pamięć, jeśli obiekt jest wskazywany wyłącznie przez pamięć podręczną, należy użyć java.lang.ref.WeakReference.

WeakReference nie zapobiega usunięciu wskazywanego obiektu przez garbage collector. Jeśli jedynymi pozostałymi odwołaniami do obiektu są słabe referencje, obiekt kwalifikuje się do usunięcia przez GC.

import java.lang.ref.WeakReference

object Main {
  def main(args: Array[String]): Unit = {
    var largeData: Array[Byte] = new Array[Byte](1024 * 1024) // 1MB
    val weakCacheEntry = new WeakReference(largeData)

    println(s"Data exists via weak ref: ${weakCacheEntry.get() != null}")

    largeData = null // Remove the strong reference

    System.gc() // Hint to the JVM to run GC
    Thread.sleep(100) // Give GC time to run

    println(s"Data collected (possibly): ${weakCacheEntry.get() == null}")
    println("WeakReference allows GC to clean up if no strong references remain.")
  }
}

Podstawowe flagi JVM do dostrajania GC

Choć GC działa automatycznie, można dostrajać jego działanie za pomocą argumentów JVM. Najważniejsze flagi to:

-Xmx: Ustawia maksymalny rozmiar sterty Java (np. -Xmx4g oznacza 4 gigabajty).
-Xms: Ustawia początkowy rozmiar sterty Java (np. -Xms512m oznacza 512 megabajtów).
-XX:+UseG1GC: Określa kolektor Garbage-First (G1), często wybierany we współczesnych aplikacjach.

Dostrajanie tych flag może znacząco wpłynąć na wydajność aplikacji i zużycie pamięci.

Sprawdź swoją wiedzę

Które z poniższych stwierdzeń dotyczących zarządzania pamięcią JVM i Garbage Collection są PRAWDZIWE?

Odpowiedz w interaktywnej lekcji

Podsumowanie: pamięć i GC

Świetnie! Poznali Państwo podstawy zarządzania pamięcią JVM i Garbage Collection:

Sterta przechowuje obiekty, a stos — wywołania metod i zmienne lokalne.
GC automatycznie odzyskuje pamięć zajmowaną przez nieosiągalne obiekty.
Zrozumienie generacyjnego GC (młodej i starej generacji) pomaga optymalizować wydajność.
Należy pamiętać o wyciekach pamięci i używać narzędzi takich jak WeakReference w określonych zastosowaniach pamięci podręcznej.
Podstawowe flagi JVM, takie jak -Xmx i -Xms, sterują rozmiarem sterty.

Następnie przyjrzymy się narzędziom do profilowania, które pomagają identyfikować wąskie gardła!

Bezpłatny start

Ucz się Scala dzięki korepetycjom AI — za darmo

Pisz i uruchamiaj kod w przeglądarce, otrzymuj natychmiastową pomoc od korepetytora AI dostępnego 24/7 i kontynuuj naukę w sieci lub w aplikacji.

Kursy: 39
Lekcje: 143

Zacznij naukę bezpłatnie Wyświetl pełny kurs

Często zadawane pytania

Czy lekcja „Zarządzanie pamięcią i dostrajanie GC” jest bezpłatna?

Tak — pełny tekst „Zarządzanie pamięcią i dostrajanie GC” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Scala for Backend Engineering & Functional Programming, przejdź na CoddyKit PRO. Kurs Scala for Backend Engineering & Functional Programming zawiera 3 lekcji w sumie.

Co nauczysz się w „Zarządzanie pamięcią i dostrajanie GC”?

Dogłębnie poznaj zarządzanie pamięcią JVM, garbage collection oraz techniki optymalizacji wykorzystania pamięci w Scali. Ćwiczysz Scala for Backend Engineering & Functional Programming z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Scala for Backend Engineering & Functional Programming?

Nie wymagamy żadnego doświadczenia. Scala for Backend Engineering & Functional Programming w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 2 z 3.

Ile czasu zajmuje lekcja „Zarządzanie pamięcią i dostrajanie GC”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Scala for Backend Engineering & Functional Programming?

Tak. Każda lekcja Scala for Backend Engineering & Functional Programming zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

Profilowanie aplikacji Scala
Zarządzanie pamięcią i dostrajanie GC
Optymalizacja kodu współbieżnego

← Powrót do Scala for Backend Engineering & Functional Programming