CodeGym /Kursy /JAVA 25 SELF /Zmienne lokalne, wycieki pamięci, słabe referencje

Zmienne lokalne, wycieki pamięci, słabe referencje

JAVA 25 SELF
Poziom 64, Lekcja 2
Dostępny

1. Gdzie przechowywane są zmienne lokalne

Zacznijmy od najprostszego: zmienne lokalne. To zmienne, które są deklarowane wewnątrz metody i istnieją tylko podczas jej wykonywania. Ich życie jest krótkie i dramatyczne: gdy tylko metoda się zakończy, wszystkie jej zmienne lokalne znikają bez śladu.

W Javie zmienne lokalne przechowywane są na stosie. Każdy wątek ma własny stos. Jeśli metoda wywołuje inną metodę, na stos trafia nowa „ramka stosu” (stack frame) z lokalnymi zmiennymi i adresem powrotu. Gdy metoda kończy pracę, jej ramka zostaje zdjęta ze stosu.

Przykład: życie zmiennej lokalnej

public class LocalVariableDemo {
    public static void main(String[] args) {
        int a = 42; // zmienna lokalna a żyje tylko w main
        printSquare(a);
        // Zmienna b już tutaj nie istnieje!
    }

    public static void printSquare(int b) {
        int square = b * b; // zmienna lokalna square
        System.out.println("Kwadrat: " + square);
        // Po wyjściu z printSquare wszystkie zmienne lokalne znikają
    }
}

Ważna uwaga: jeśli zmienna lokalna to referencja do obiektu (na przykład String, Scanner, tablica), to sama referencja żyje na stosie, a obiekt — na stercie! Gdy referencja znika, a nie ma innych referencji do obiektu, garbage collector może ten obiekt usunąć.

Ilustracja

Stack (dla main):
| int a = 42      |
| args            |
-------------------
Heap:
| [obiekty utworzone przez new] |

2. Wycieki pamięci w Javie: mit czy rzeczywistość?

Wielu początkujących myśli: „Przecież w Javie jest garbage collector! A więc wycieki pamięci są niemożliwe!” Niestety, to mit, który rozwiewa się przy pierwszym większym projekcie.

Garbage collector usuwa tylko te obiekty, do których nie ma żadnej żywej referencji. Jeśli gdzieś została referencja (choćby w najmniej spodziewanym miejscu), obiekt będzie wisiał w pamięci do upadłego. Albo do OutOfMemoryError.

Przykład 1: Statyczna kolekcja-pułapka

import java.util.ArrayList;
import java.util.List;

public class MemoryLeakDemo {
    // Och, ta statyczna kolekcja!
    private static final List<String> BIG_LIST = new ArrayList<>();

    public static void main(String[] args) {
        for (int i = 0; i < 1_000_000; i++) {
            BIG_LIST.add("Wiersz numer " + i);
        }
        System.out.println("Dodano milion wierszy");
        // Nawet jeśli main się zakończy, BIG_LIST pozostanie w pamięci, dopóki żyje JVM
    }
}

Co się dzieje?

  • Zmienna statyczna BIG_LIST żyje tak długo, jak żyje klasa (zwykle do końca życia JVM).
  • Wszystkie łańcuchy dodane do listy nie mogą zostać usunięte przez garbage collector — zawsze istnieje do nich referencja poprzez BIG_LIST.
  • Jeśli przypadkiem zapomnisz czyścić takie kolekcje — dostaniesz wyciek pamięci.

Przykład 2: Nieodpięci słuchacze (listeners)

import java.util.ArrayList;
import java.util.List;

class EventSource {
    private final List<Runnable> listeners = new ArrayList<>();

    public void addListener(Runnable listener) {
        listeners.add(listener);
    }

    // ... inne metody ...
}

public class ListenerLeakDemo {
    public static void main(String[] args) {
        EventSource source = new EventSource();
        Runnable listener = () -> System.out.println("Zdarzenie!");
        source.addListener(listener);
        // Jeśli zapomnisz wywołać source.removeListener(listener), listener pozostanie w pamięci na zawsze!
    }
}

Problem: jeśli słuchacz nie jest już potrzebny, ale nie został usunięty z listy — on i wszystkie obiekty, do których się odwołuje, pozostaną w pamięci.

Przykład 3: Cache, który nigdy się nie opróżnia

import java.util.HashMap;
import java.util.Map;

public class CacheLeakDemo {
    private static final Map<String, byte[]> CACHE = new HashMap<>();

    public static void main(String[] args) {
        for (int i = 0; i < 1_000_000; i++) {
            // Za każdym razem tworzymy tablicę 1 KB
            CACHE.put("key" + i, new byte[1024]);
        }
        System.out.println("Dodano milion elementów do cache'a");
        // Cache rośnie, pamięć się kończy, OutOfMemoryError!
    }
}

Wniosek: nawet z GC można łatwo doprowadzić do wycieku pamięci, jeśli nie pilnuje się cyklu życia obiektów!

3. Słabe referencje (WeakReference) i ich przyjaciele

Czasem potrzebujemy cache'y lub kolekcji, w których obiekty mogą być usuwane przez garbage collector, jeśli nikt inny się do nich nie odwołuje. Do tego służą słabe referencje (WeakReference).

Zwykłe (strong) referencje

String s = new String("hello"); // referencja strong

Obiekt s będzie żył w pamięci, dopóki istnieje choć jedna referencja strong.

Słaba referencja (WeakReference)

import java.lang.ref.WeakReference;

public class WeakRefDemo {
    public static void main(String[] args) {
        String strong = new String("Witaj, świecie!");
        WeakReference<String> weak = new WeakReference<>(strong);

        System.out.println("Przed czyszczeniem: " + weak.get()); // jest referencja

        strong = null; // usuwamy referencję strong

        System.gc(); // prosimy GC o sprzątnięcie pamięci (niegwarantowane!)

        // Po pewnym czasie weak.get() może zwrócić null
        System.out.println("Po GC: " + weak.get());
    }
}

Jak to działa?

  • Dopóki istnieje choć jedna referencja strong do obiektu, GC go nie usunie.
  • Jeśli pozostaną tylko słabe referencje, obiekt może zostać usunięty przy następnej zbiórce.
  • Metoda weak.get() zwraca obiekt, jeśli wciąż żyje, lub null, jeśli obiekt usunięto.

Gdzie stosować słabe referencje?

Główne zastosowanie — cache, gdzie nie jest krytyczne, jeśli obiekt zostanie usunięty z pamięci. Na przykład gdy buforujesz obrazy, ale nie chcesz, aby cache zajmował całą pamięć.

Przykład: WeakHashMap

WeakHashMap — to kolekcja, w której klucze są przechowywane poprzez słabe referencje. Jeśli do klucza nikt więcej się nie odwołuje, odpowiednia para zostaje usunięta z mapy.

import java.util.Map;
import java.util.WeakHashMap;

public class WeakHashMapDemo {
    public static void main(String[] args) {
        Map<Object, String> map = new WeakHashMap<>();
        Object key = new Object();
        map.put(key, "Wartość");

        System.out.println("Przed czyszczeniem: " + map);

        key = null; // usuwamy referencję strong do klucza

        System.gc(); // prosimy GC o pracę

        // Po pewnym czasie mapa stanie się pusta!
        try { Thread.sleep(100); } catch (InterruptedException ignored) {}
        System.out.println("Po GC: " + map);
    }
}

Uwaga: WeakHashMap działa tylko dla kluczy — wartości przechowywane są zwykłymi referencjami strong.

Soft, Weak, Phantom: cała rodzina referencji

W Javie istnieją cztery typy referencji (posortowane według „siły”):

Typ referencji Kiedy obiekt jest usuwany przez GC? Zastosowania
Strong
Tylko gdy nie ma żadnej referencji strong Zwykłe zmienne, kolekcje
Soft
Przy niedoborze pamięci Cache, który warto trzymać dłużej
Weak
Przy następnym przebiegu GC, jeśli nie ma referencji strong Cache, WeakHashMap, słuchacze
Phantom
Po finalizacji, do śledzenia usunięcia obiektu Zadania specjalne, czyszczenie poza stertą
  • SoftReference — obiekt jest usuwany przy niedoborze pamięci (dobrze nadaje się do cache'u obrazów itp.).
  • WeakReference — usuwany przy pierwszej zbiórce, jeśli nie ma innych referencji.
  • PhantomReference — najbardziej „widmowy” typ, potrzebny do złożonych scenariuszy, rzadko używany przez początkujących.

4. Praktyka: przykład wycieku pamięci i jego naprawa

Przykład wycieku: lista statyczna

import java.util.ArrayList;
import java.util.List;

public class LeakExample {
    private static final List<byte[]> list = new ArrayList<>();

    public static void main(String[] args) {
        for (int i = 0; i < 100_000; i++) {
            list.add(new byte[1024 * 1024]); // 1 MB
            if (i % 10 == 0) System.out.println("Dodano " + i + " MB");
        }
    }
}

Co się stanie?
Program szybko zje całą dostępną pamięć i zakończy się OutOfMemoryError, ponieważ statyczna lista przechowuje referencje do wszystkich utworzonych tablic.

Naprawa: użyć słabych referencji

Jeśli nie jest krytyczne, aby wszystkie obiekty były zawsze dostępne, można je przechowywać poprzez słabe referencje:

import java.lang.ref.WeakReference;
import java.util.ArrayList;
import java.util.List;

public class LeakFixed {
    private static final List<WeakReference<byte[]>> list = new ArrayList<>();

    public static void main(String[] args) {
        for (int i = 0; i < 100_000; i++) {
            list.add(new WeakReference<>(new byte[1024 * 1024]));
            if (i % 10 == 0) System.out.println("Dodano " + i + " MB");
            System.gc(); // Wskazówka dla GC (nie gwarantuje natychmiastowego czyszczenia!)
        }
    }
}

Teraz tablice mogą zostać usunięte przez GC, jeśli nikt już się do nich nie odwołuje — lista przechowuje tylko słabe referencje.

5. Typowe scenariusze wycieków pamięci

  • Słuchacze zdarzeń: zapomniano usunąć słuchacza — obiekt żyje wiecznie.
  • Statyczne kolekcje: nieczyszczone cache'e, globalne listy — to wszystko może prowadzić do wycieków.
  • Klasy wewnętrzne i lambdy: jeśli klasa wewnętrzna lub lambda przechwytuje referencję do obiektu zewnętrznego, nie zostanie on usunięty, dopóki żyje obiekt zewnętrzny.

Przykład z klasą wewnętrzną

public class Outer {
    private byte[] bigArray = new byte[1024 * 1024 * 100]; // 100 MB

    public Runnable createTask() {
        // Anonimowa klasa wewnętrzna przechwytuje referencję do Outer!
        return new Runnable() {
            @Override
            public void run() {
                System.out.println("Zadanie jest wykonywane");
            }
        };
    }

    public static void main(String[] args) {
        Outer outer = new Outer();
        Runnable task = outer.createTask();
        // Nawet jeśli outer = null, task nadal trzyma referencję do bigArray!
    }
}

Rozwiązanie: używaj statycznych klas wewnętrznych albo wynoś logikę do osobnych klas, aby nie trzymać zbędnych referencji.

6. Praktyka: użycie słabych referencji w cache'u

Dodajmy do aplikacji edukacyjnej najprostszy cache z użyciem WeakHashMap.

import java.util.Map;
import java.util.WeakHashMap;

public class ImageCache {
    private final Map<String, byte[]> cache = new WeakHashMap<>();

    public void put(String name, byte[] data) {
        cache.put(name, data);
    }

    public byte[] get(String name) {
        return cache.get(name);
    }

    public static void main(String[] args) {
        ImageCache cache = new ImageCache();
        cache.put("cat", new byte[1024 * 1024]); // 1 MB
        System.out.println("Kot dodany do cache'a");

        // Jeśli do klucza "cat" nie ma już żadnych referencji, obiekt może zostać usunięty przez GC
    }
}

W rzeczywistych aplikacjach (np. w bibliotekach obrazów) słabe referencje pomagają uniknąć przepełnienia pamięci dzięki automatycznemu usuwaniu rzadko używanych danych.

7. Strong vs Weak: kiedy czego używać?

  • Referencje strong — domyślnie: używaj ich do wszystkiego, co ma żyć gwarantowanie.
  • Słabe referencje — do cache'y, słuchaczy, gdy nie jest krytyczne, jeśli obiekt zostanie usunięty.
  • Referencje soft — do cache'y, które warto trzymać dłużej, ale można usunąć przy braku pamięci.
  • Referencje phantom — do zaawansowanych scenariuszy (np. finalizacja poza stertą).

8. Typowe błędy w pracy z pamięcią i referencjami

Błąd nr 1: „GC wszystko za mnie posprząta!” Garbage collector usuwa tylko te obiekty, do których nie ma żadnej żywej referencji strong. Jeśli gdzieś „zapomnisz” referencję (np. w static-kolekcji), obiekt będzie żył wiecznie.

Błąd nr 2: Zapomniani słuchacze. Dodałeś słuchacza do obiektu, ale nie usunąłeś go przy niszczeniu obiektu? Słuchacz i wszystko, co przechwycił, pozostanie w pamięci.

Błąd nr 3: Cache bez słabych referencji. Używasz zwykłej HashMap dla cache'a, który ma automatycznie się czyścić? Lepiej użyj WeakHashMap albo SoftReference.

Błąd nr 4: Klasy wewnętrzne i lambdy przechwytują obiekt zewnętrzny. Klasy wewnętrzne (i wyrażenia lambda) niejawnie przechowują referencję do obiektu zewnętrznego. Jeśli przechowujesz instancje takich klas dłużej niż sam obiekt zewnętrzny, dostaniesz wyciek.

Błąd nr 5: Oczekiwanie natychmiastowego zadziałania GC. Wywołanie System.gc() nie gwarantuje, że zbiórka śmieci nastąpi od razu. To jedynie „prośba” do JVM, a nie rozkaz.

1
Zadanie
JAVA 25 SELF, poziom 64, lekcja 2
Niedostępne
Użycie słabej referencji – Wiadomość na Znikającym Atramencie 👻
Użycie słabej referencji – Wiadomość na Znikającym Atramencie 👻
1
Zadanie
JAVA 25 SELF, poziom 64, lekcja 2
Niedostępne
Pamięć podręczna z użyciem WeakHashMap – Inteligentna biblioteka, która przetwarza zapomniane książki 📚
Pamięć podręczna z użyciem WeakHashMap – Inteligentna biblioteka, która przetwarza zapomniane książki 📚
Komentarze
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION