Garbage Collector w Javie. Podstawy i działanie

Ewa Klimowicz

14 lutego, 2024

3 min

• Specjalizacja
• Java

Ostatnia aktualizacja 14 lutego, 2024

Java Virtual Machine stanowi serce środowiska wykonawczego Javy. Umożliwia aplikacjom napisanym w tym języku działanie na dowolnym urządzeniu, bez potrzeby modyfikacji. Java Virtual Machine ułatwia pracę poprzez automatyczne zarządzanie pamięcią, w którym mechanizm znany jako Garbage Collector (GC) pełni główną rolę. W tym artykule przybliżymy sposoby współpracy GC z JVM.

Mechanizm działania Garbage Collectora w Java Virtual Machine

Garbage Collector w środowisku maszyny wirtualnej Javy odpowiada za wykrywanie i zwalnianie pamięci zajmowanej przez obiekty, które nie są już potrzebne. Proces ten jest niezbędny, aby zapobiegać wyciekom pamięci i utrzymać płynne działanie aplikacji. GC w JVM wykorzystuje różnorodne algorytmy, z których najbardziej rozpowszechnione to:

• Mark and Sweep: Ta technika składa się z dwóch faz – oznacza dostępne obiekty, a następnie “zamiata” te nieoznaczone, zwalniając pamięć.
• Generational Collection: Podział pamięci na pokolenia pozwala JVM skupić się na czyszczeniu tych obszarów pamięci, w których obiekty są krótkotrwałe, co przyspiesza proces GC.

Sprawdź też: Praca Olsztyn

Kontrola i wyzwalacze Garbage Collectora

Moment uruchomienia Garbage Collectora może zależeć od wielu czynników, w szczególności od dostępności pamięci i działania aplikacji. JVM oferuje jednak opcje konfiguracji i optymalizacji pracy GC, pozwalając na pewien stopień kontroli nad tym procesem.

Metoda System.gc() może sugerować JVM potrzebę uruchomienia GC, jednak ostateczna decyzja należy do maszyny wirtualnej. Poniższy przykład kodu w Javie ilustruje, jak można sugerować JVM wykonanie Garbage Collector:

public class GCDemo {

    public static void main(String[] args) {
        System.out.println("Przed wywołaniem System.gc()");
        printMemoryUsage();

        // Tworzenie dużych obiektów, które zajmują sporo miejsca w pamięci
        createWaste();

        System.out.println("Po utworzeniu śmieci, przed ręcznym wywołaniem GC");
        printMemoryUsage();

        // Sugestia dla JVM, że może to być dobry moment na uruchomienie Garbage Collector
        System.gc();

        // Czekamy chwilę, aby dać GC czas na działanie
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Po wywołaniu System.gc()");
        printMemoryUsage();
    }

    private static void createWaste() {
        for (int i = 0; i < 1000; i++) {
            byte[] waste = new byte[1024 * 1024]; // Alokacja 1MB
        }
    }

    private static void printMemoryUsage() {
        Runtime runtime = Runtime.getRuntime();
        long totalMemory = runtime.totalMemory();
        long freeMemory = runtime.freeMemory();
        long usedMemory = totalMemory - freeMemory;
        System.out.println("Używana pamięć: " + usedMemory + " bajtów");
    }
}

1. W tym przykładzie najpierw wyświetlone jest zużycie pamięci przed alokacją dużej ilości danych.
2. Następnie tworzone są “śmieci” – obiekty, które zajmują sporo miejsca w pamięci, ale nie będą używane.
3. Po alokacji tych obiektów ponownie sprawdzane jest zużycie pamięci, a następnie wywoływana jest metoda System.gc(), która sugeruje JVM, że może to być odpowiedni moment na uruchomienie Garbage Collectora. Po krótkim odczekaniu (aby dać czas na działanie GC, jeśli JVM zdecyduje się na jego uruchomienie) ponownie sprawdzane jest zużycie pamięci.

Należy jednak podkreślić, że wykorzystanie metody System.gc() w produkcji jest generalnie uważane za złą praktykę, ponieważ może prowadzić do nieprzewidywalnego zachowania aplikacji i zmniejszenia wydajności. Zamiast tego lepiej polegać na automatycznym zarządzaniu pamięcią przez JVM.

Dalsza część tekstu znajduje się pod materiałem wideo:

Optymalizacja zarządzania pamięcią

Mimo że Garbage Collector działa automatycznie, programiści mogą podjąć kroki, aby zoptymalizować zarządzanie pamięcią w swoich aplikacjach:

1. Zmniejszanie ilości tworzonych obiektów: Ograniczając tworzenie niepotrzebnych obiektów, można zmniejszyć obciążenie GC i poprawić wydajność aplikacji.
2. Wykorzystanie słabych referencji: W odpowiednich sytuacjach słabe referencje mogą ułatwić szybsze zwalnianie pamięci przez GC.
3. Profilowanie aplikacji: Narzędzia do profilowania mogą pomóc w identyfikacji problemów z zarządzaniem pamięcią, umożliwiając ich skuteczne rozwiązanie.

Czytaj także:

Co warto wiedzieć o JVM?

Machine Learning ulepszony informacjami zwrotnymi