1. Typowe błędy przy pracy z pamięcią
Czas spojrzeć na drugą stronę magii automatycznego zarządzania pamięcią. Nawet jeśli nie piszesz w C, gdzie każdy bajt trzeba pilnować ręcznie, w Javie też można narobić takich błędów, że aplikacja będzie pożerać pamięć jak żarłoczny kot — kiełbasę. Przyjrzyjmy się najczęstszym błędom i sposobom, jak ich uniknąć.
Zapomniani słuchacze (listeners)
W Javie często używa się wzorca „słuchacz” — obiektu, który subskrybuje zdarzenia innego obiektu. Na przykład utworzyłeś przycisk i dodałeś do niego obsługę kliknięcia:
button.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
// obsługa kliknięcia
}
});
Problem: jeśli zapomnisz usunąć tego słuchacza (removeActionListener), gdy przycisk lub okno nie są już potrzebne, słuchacz pozostaje w pamięci. Nawet jeśli zamknąłeś okno i wyzerowałeś wszystkie referencje do niego, obiekt‑słuchacz wciąż trzyma referencję do okna (albo odwrotnie), nie pozwalając garbage collectorowi zwolnić pamięci.
Analogia: Wyobraź sobie, że się przeprowadziłeś, ale zapomniałeś wypisać się z newslettera pizzerii — nadal wysyłają reklamy na stary adres.
Statyczne kolekcje bez czyszczenia
Pola statyczne żyją tak długo, jak klasa (a czasem — do końca życia aplikacji). Jeśli masz statyczną kolekcję:
public class Cache {
public static final List<String> globalList = new ArrayList<>();
}
i dodajesz tam obiekty, ale ich nie usuwasz, będą wisieć w pamięci wiecznie. Nawet jeśli nigdzie indziej nie ma już do nich referencji, odwołanie ze statycznej kolekcji nie pozwoli GC ich uprzątnąć.
Prawdziwy przykład: Cache zdjęć w aplikacji desktopowej, który nigdy się nie czyści. Po kilku godzinach pracy — OutOfMemoryError.
Niezwalnianie zasobów (pliki, strumienie, połączenia)
Choć Java zwalnia pamięć, nie zajmuje się automatycznym zamykaniem deskryptorów plików, połączeń sieciowych i innych zasobów zewnętrznych. Jeśli zapomnisz zamknąć plik lub strumień, zasób pozostanie zajęty i w pewnym momencie system powie: „Wystarczy, więcej plików nie dostaniesz!” (IOException: Too many open files).
Wskazówka: Zawsze używaj try-with-resources:
try (FileInputStream in = new FileInputStream("data.txt")) {
// czytamy plik
} // in.close() zostanie wywołane automatycznie!
Duże obiekty, które długo wiszą w pamięci
Czasem tworzysz dużą tablicę lub kolekcję, używasz jej, a potem „zapominasz ją zwolnić”. Na przykład:
List<byte[]> bigList = new ArrayList<>();
for (int i = 0; i < 1000; i++) {
bigList.add(new byte[1024 * 1024]); // 1 MB każdy
}
// ... zapomniano wyczyścić bigList
Jeśli ta kolekcja żyje w polu statycznym albo w obiekcie, który długo nie jest usuwany, cała ta pamięć pozostanie zajęta.
Klasy wewnętrzne i anonimowe: przechwytywanie zewnętrznych referencji
Klasy anonimowe (i wewnętrzne) w Javie przechowują niejawne odwołanie do obiektu zewnętrznego:
public class Outer {
void doSomething() {
Runnable r = new Runnable() {
@Override
public void run() {
System.out.println("Hello from inner!");
}
};
// r gdzieś jest zapisywany
}
}
Jeśli obiekt r trafi do statycznej kolekcji lub cache, będzie „trzymał” referencję do instancji Outer, nawet jeśli ta nie jest już potrzebna. W rezultacie — wyciek pamięci. Z wyrażeniami lambda sytuacja jest nieco lepsza, ale jeśli lambda używa pól klasy zewnętrznej, referencja i tak zostaje zachowana.
2. Błędy w obchodzeniu się z garbage collectorem
Wymuszanie wywołania System.gc()
Wielu początkujących myśli: „Pamięć się kończy — wywołam System.gc() i wszystko się rozwiąże!”. W rzeczywistości to tylko prośba do JVM, a nie gwarancja natychmiastowej zbiórki. Częste użycie może mocno pogorszyć wydajność, wywołać długie pauzy i przycięcia. W realnych aplikacjach lepiej zaufać JVM — sama zdecyduje, kiedy zbierać śmieci. Co więcej, niektóre JVM mogą ignorować jawne wywołania GC (np. z opcją -XX:+DisableExplicitGC).
Ignorowanie logów GC
W logach GC widać, kiedy zachodzą zbiórki, ile czasu trwają i ile pamięci jest zwalniane. Jeśli nie zaglądasz do tych logów, możesz przeoczyć sygnały problemów: długie pauzy, częste Full GC, wycieki pamięci.
Jak włączyć logi GC:
java -Xlog:gc* -jar MyApp.jar
albo dla starszych JVM:
java -XX:+PrintGCDetails -XX:+PrintGCDateStamps -jar MyApp.jar
Niewłaściwy dobór GC do zadania
Wybór kolektora wpływa na opóźnienia i stabilność. Dla niskiej latencji (giełdy, gry online) równoległy stop‑the‑world Parallel GC to zły pomysł: może „zamrażać” wszystkie wątki na czas zbiórki. Rozważ G1 GC, ZGC albo Shenandoah.
3. Błędy z kolekcjami
Użycie HashMap zamiast WeakHashMap do cache’y.
Jeśli tworzysz cache, w którym obiekty powinny być automatycznie usuwane, gdy nie ma już do nich „żywych” referencji, użyj WeakHashMap:
Map<Key, Value> cache = new WeakHashMap<>();
Zwykła HashMap sprawi, że obiekty będą żyły, dopóki cache nie zostanie wyczyszczony ręcznie, co prowadzi do wycieku pamięci.
Zapomniane remove() elementów.
Jeśli dodajesz obiekty do kolekcji (np. do list słuchaczy), ale nie usuwasz ich, gdy nie są już potrzebne, te obiekty będą żyły wiecznie, zwłaszcza w długo żyjących kolekcjach (np. statycznych).
4. Best practices: jak uniknąć problemów
Zawsze usuwaj słuchaczy.
Jeśli obiekt zapisał się na zdarzenia, koniecznie wypisz go, gdy nie jest już potrzebny. Wygodnie zrobić to w metodzie dispose() lub przy zamknięciu okna/ekranu.
button.removeActionListener(myListener);
Używaj słabych referencji dla cache’y.
Jeśli w cache’u można się obyć bez gwarancji utrzymania obiektu, używaj WeakReference lub kolekcji na ich bazie (WeakHashMap). Dzięki temu GC zwolni pamięć, kiedy będzie potrzebna.
Monitoruj pamięć na produkcji.
Używaj jvisualvm, jconsole albo systemów APM. To pomaga wychwycić wycieki, zanim użytkownicy zaczną narzekać.
Analizuj heap dump, gdy podejrzewasz wyciek
Jeśli aplikacja zaczęła pożerać więcej pamięci niż zwykle, zrób heap dump (np. przez jmap albo jvisualvm) i sprawdź, które obiekty zajmują najwięcej miejsca. Często winowajcę da się znaleźć w kilka minut.
Konfiguruj parametry JVM.
- -Xmx — maksymalny rozmiar sterty
- -Xms — początkowy rozmiar sterty
Rozsądne limity pomagają uniknąć OutOfMemoryError i przyspieszają diagnostykę.
5. Praktyka: przykład kodu z wyciekiem pamięci i jego naprawa
Przykład 1: Wyciek przez statyczną kolekcję
public class MemoryLeakDemo {
// Statyczna kolekcja — żyje wiecznie
private static final List<byte[]> leakyList = new ArrayList<>();
public static void main(String[] args) {
for (int i = 0; i < 1000; i++) {
leakyList.add(new byte[1024 * 1024]); // 1 MB za każdym razem
System.out.println("Dodano " + (i + 1) + " MB");
}
// OutOfMemoryError!
}
}
Naprawa: Użyj zmiennej lokalnej albo czyść kolekcję, gdy nie jest już potrzebna.
public class MemoryLeakFixed {
public static void main(String[] args) {
List<byte[]> tempList = new ArrayList<>();
for (int i = 0; i < 1000; i++) {
tempList.add(new byte[1024 * 1024]);
System.out.println("Dodano " + (i + 1) + " MB");
}
// tempList = null; // Można jawnie wyzerować
// Teraz obiekty są dostępne dla GC po wyjściu z metody
}
}
Przykład 2: Wyciek przez słuchacza
public class Window {
private final List<EventListener> listeners = new ArrayList<>();
public void addListener(EventListener l) {
listeners.add(l);
}
// Brak metody removeListener!
}
Naprawa: Dodaj metodę usuwania słuchacza i wywołuj ją przy zamknięciu okna.
public void removeListener(EventListener l) {
listeners.remove(l);
}
Przykład 3: Cache z HashMap zamiast WeakHashMap
Map<Object, Object> cache = new HashMap<>();
// ... dodajemy obiekty
Naprawa: Przejdź na WeakHashMap:
Map<Object, Object> cache = new WeakHashMap<>();
Wskazówki dot. konfiguracji JVM do monitorowania pamięci
- Włączaj logi GC: -Xlog:gc* albo -XX:+PrintGCDetails
- Ogranicz maksymalny rozmiar sterty: -Xmx512m
- Jeśli używasz cache’y — pilnuj ich rozmiaru i stosuj słabe referencje, jeśli to dopuszczalne
- Eksperymentuj z GC: -XX:+UseG1GC, -XX:+UseZGC, -XX:+UseShenandoahGC
7. Typowe błędy przy pracy z pamięcią
Błąd nr 1: Zapomniani słuchacze i subskrypcje. Jeśli dodałeś słuchacza do obiektu, ale zapomniałeś go usunąć, obiekt‑słuchacz (i wszystko, do czego się odwołuje) pozostanie w pamięci. Klasyka dla GUI i systemów zdarzeń. Używaj removeListener/removeActionListener.
Błąd nr 2: Statyczne kolekcje bez czyszczenia. Pola statyczne żyją najdłużej. Jeśli wkładasz do nich obiekty i nie czyścisz kolekcji, te obiekty zostaną w pamięci na zawsze. Szczególnie zdradliwe w bezdennych cache’ach.
Błąd nr 3: Niezwalnianie zasobów zewnętrznych. Zostawiłeś otwarty strumień, plik lub połączenie? Tracisz pamięć i uderzasz w limity systemu. Używaj try-with-resources i zamykaj zasoby.
Błąd nr 4: Wymuszanie wywołania System.gc(). To nie panaceum, a jedynie prośba do JVM. Często prowadzi do pauz i degradacji wydajności.
Błąd nr 5: Zwykłe kolekcje do cache’y. Jeśli obiekty w cache’u powinny usuwać się same, stosuj słabe/soft‑referencje (WeakHashMap, SoftReference). Inaczej skończysz z wyciekiem.
Błąd nr 6: Klasy wewnętrzne i anonimowe, przechwytujące zewnętrzne referencje. Klasy wewnętrzne i lambdy mogą niejawnie utrzymywać referencję do obiektu zewnętrznego. Jeśli zapiszesz je w długo żyjącej kolekcji — to wyciek.
Błąd nr 7: Ignorowanie logów GC. Jeśli nie oglądasz logów GC, nie dowiesz się o długich pauzach lub częstych Full GC — a użytkownicy dowiedzą się po lagach i przycięciach. Włącz -Xlog:gc* albo -XX:+PrintGCDetails.
GO TO FULL VERSION