1. Wprowadzenie do profilowania
Profilowanie — to jak badanie lekarskie dla twojego programu: nie patrzymy tylko na „temperaturę” (monitoring), ale szukamy, gdzie aplikacja „boli”, co działa wolno, gdzie zużywa zbyt dużo pamięci lub zasobów.
Profilowanie — to proces zbierania i analizy informacji o pracy programu w celu wykrycia wąskich gardeł (bottlenecks) i nieefektywnych fragmentów kodu. W odróżnieniu od monitoringu, który zwykle śledzi ogólne wskaźniki (obciążenie CPU, pamięć, liczba wątków), profilowanie pozwala zajrzeć do środka: dowiedzieć się, które metody są wywoływane najczęściej, ile czasu zajmują, ile obiektów jest tworzonych i gdzie dokładnie dochodzi do wycieku pamięci.
Kiedy profilowanie jest naprawdę potrzebne?
- Aplikacja „zamula”, ale nie wiadomo, dlaczego.
- Nagle wzrosło zużycie pamięci.
- Po aktualizacji kodu coś zaczęło działać dłużej.
- Trzeba zrozumieć, dlaczego serwerowi brakuje zasobów.
Na marginesie: niemal każdy programista choć raz w życiu optymalizował nie ten fragment kodu. Dlaczego? Bo „na oko” określić wąskie gardło jest praktycznie niemożliwe — do tego potrzebny jest profiler.
Podstawowe metryki profilowania
- Czas wykonywania metod (profilowanie CPU): Które metody zajmują najwięcej czasu? Gdzie program „zużywa” CPU?
- Zużycie pamięci (profilowanie pamięci): Jakie obiekty są tworzone najczęściej? Gdzie pozostają w pamięci dłużej, niż to potrzebne?
- Liczba obiektów: Czy nie tworzymy zbyt wielu jednorodnych obiektów?
- Wątki: Czy wątków nie jest zbyt dużo? Czy nie ma blokad (deadlock, contention)?
- Wywołania metod: Jaka jest głębokość stosu? Czy nie zachodzi rekurencja bez wyjścia?
2. Narzędzia profilowania
W świecie Javy jest kilka klasycznych (i darmowych!) narzędzi, które pozwalają prowadzić profilowanie. Omówmy najważniejsze.
VisualVM
VisualVM — to darmowe narzędzie, które wchodzi w skład JDK (począwszy od JDK 6). Umożliwia:
- Łączenie się z lokalnymi i zdalnymi JVM.
- Podgląd pamięci, wątków, CPU i działania garbage collectora.
- Tworzenie heap dump i jego analizę.
- Profilowanie aplikacji pod kątem CPU i pamięci.
Jak uruchomić VisualVM?
Zwykle znajduje się w katalogu JDK: <sciezka_do_JDK>/bin/jvisualvm
Uruchamiasz, wybierasz proces aplikacji Java — i możesz obserwować jej życie jak rybki w akwarium (tyle że rybki to tutaj obiekty i wątki).
JProfiler, YourKit
To narzędzia komercyjne, ale bardzo mocne. Umożliwiają:
- Profilowanie pamięci, CPU i wątków.
- Analizę „zrzutów” pamięci (heap dump).
- Wyszukiwanie wycieków, długich blokad, wolnych metod.
- Integrację z IDE oraz CI/CD.
Na początek wystarczy VisualVM, ale jeśli „dorośniesz” do większych projektów — przyjrzyj się tym narzędziom.
Java Flight Recorder (JFR)
JFR — to wbudowane w JDK narzędzie do zbierania zdarzeń dotyczących pracy JVM. Jest bardzo lekkie, prawie nie wpływa na wydajność i pozwala zbierać informacje o:
- Czasie pracy metod.
- Garbage collectingu.
- Wątkach, blokadach, błędach.
JFR świetnie nadaje się do pracy na produkcji, gdy nie można spowalniać aplikacji.
3. Praktyka: profilujemy prostą aplikację
Stwórzmy mini-kalkulator, który potrafi wykonywać długie obliczenia i przechowywać historię operacji (żebyśmy mieli pętle, kolekcje i pracę z pamięcią).
Przykład kodu: „Powolny kalkulator”
import java.util.ArrayList;
import java.util.List;
public class SlowCalculator {
private final List<String> history = new ArrayList<>();
public int add(int a, int b) {
simulateHeavyOperation();
int result = a + b;
history.add(a + " + " + b + " = " + result);
return result;
}
public int multiply(int a, int b) {
simulateHeavyOperation();
int result = a * b;
history.add(a + " * " + b + " = " + result);
return result;
}
public List<String> getHistory() {
return history;
}
// Symulacja "ciężkiej" operacji
private void simulateHeavyOperation() {
for (int i = 0; i < 5_000_000; i++) {
Math.sqrt(i);
}
}
}
A teraz — klasa główna:
public class Main {
public static void main(String[] args) {
SlowCalculator calc = new SlowCalculator();
for (int i = 0; i < 10; i++) {
calc.add(i, i * 2);
calc.multiply(i, i + 5);
}
System.out.println("Historia operacji:");
for (String entry : calc.getHistory()) {
System.out.println(entry);
}
}
}
Jak profilować tę aplikację?
- Skompiluj i uruchom aplikację.
- Otwórz VisualVM (jvisualvm).
- Znajdź swój proces (zwykle po nazwie klasy Main).
- Przejdź do zakładki CPU Profiler i kliknij Start.
- Pozwól programowi popracować (albo naciśnij „wolny” przycisk jeszcze raz).
- Sprawdź, które metody zajmują najwięcej czasu.
Pytanie: Która metoda, twoim zdaniem, będzie najbardziej „ciężka”?
Odpowiedź: Oczywiście simulateHeavyOperation() — w końcu kręci ogromną pętlę z 5_000_000 iteracji i wywołuje Math.sqrt.
4. Typowe problemy z wydajnością
Powolne algorytmy
Najczęstsza przyczyna: nieudany wybór algorytmu lub struktury danych. Na przykład, wyszukiwanie na liście zamiast użycia HashMap albo sortowanie bąbelkowe zamiast szybkiego sortowania.
Przykład:
// Powolne wyszukiwanie
for (String s : list) {
if (s.equals("target")) {
// znaleziono
}
}
Lepiej użyć Set lub Map do szybkiego wyszukiwania.
Wycieki pamięci
Wycieki pamięci — to sytuacja, gdy obiekty pozostają „żywe” (istnieją do nich referencje), chociaż nie są już potrzebne. Prowadzi to do wzrostu zużycia pamięci, a w konsekwencji do OutOfMemoryError.
public class MemoryLeakDemo {
private static List<byte[]> leakyList = new ArrayList<>();
public static void main(String[] args) {
while (true) {
leakyList.add(new byte[1_000_000]); // 1 MB
try { Thread.sleep(100); } catch (InterruptedException ignored) {}
}
}
}
Jak znajdować wycieki?
Zrób heap dump w VisualVM i sprawdź, które obiekty zajmują najwięcej pamięci oraz dlaczego istnieją do nich referencje.
Nadmierne tworzenie obiektów
Jeśli w pętli tworzysz wiele jednorodnych obiektów, obciąża to nie tylko garbage collector, ale też może spowalniać aplikację.
for (int i = 0; i < 1_000_000; i++) {
String s = new String("hello"); // źle!
}
Lepiej używać stałych lub puli łańcuchów (String pool).
Blokady wątków
Jeśli kilka wątków walczy o ten sam zasób (np. zsynchronizowaną metodę), może to prowadzić do blokad i spadku wydajności.
public synchronized void doWork() {
// ...
}
Jak wykrywać?
W zakładce Threads w VisualVM możesz zobaczyć, które wątki „wiszą” i dlaczego.
5. Podejścia do optymalizacji
Najpierw mierz, potem optymalizuj
Główna zasada optymalizacji: Nie optymalizuj tego, co nie spowalnia.
Najpierw profiluj, znajdź „gorące miejsca”, a dopiero potem zmieniaj kod. Czasami najbardziej „oczywisty” fragment kodu zajmuje zaledwie 1 % czasu, a prawdziwy „potwór” kryje się w bibliotece albo w nieoczekiwanym miejscu.
Użycie profilera do wyszukiwania gorących miejsc
Gorące miejsce — to metoda lub fragment kodu, który zajmuje największą część czasu działania aplikacji.
W VisualVM widać to na karcie CPU Profiler:
- Sortuj metody według czasu wykonania.
- Patrz na stack trace: kto kogo wywołuje.
- Pamiętaj, że czasem „winny” jest nie twój kod, lecz biblioteka albo nawet JDK.
Przykłady optymalizacji
Przykład 1: Zamiana algorytmu
Jeśli odkryłeś, że najwięcej czasu schodzi na wyszukiwanie w liście, zamień List na HashSet.
Set<String> set = new HashSet<>(list);
if (set.contains("target")) {
// szybko!
}
Przykład 2: Zmniejszenie liczby alokacji
Zamiast tworzyć nowe obiekty w pętli, używaj ponownego wykorzystania albo StringBuilder.
// Źle:
for (int i = 0; i < 10000; i++) {
String s = "Wynik: " + i;
}
// Lepiej:
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 10000; i++) {
sb.setLength(0);
sb.append("Wynik: ").append(i);
String s = sb.toString();
}
Przykład 3: Buforowanie
Jeśli widzisz, że ciężka metoda jest wywoływana wiele razy z tymi samymi parametrami, użyj cache.
Map<Integer, Double> sqrtCache = new HashMap<>();
public double cachedSqrt(int x) {
return sqrtCache.computeIfAbsent(x, Math::sqrt);
}
6. Demonstracja: przyspieszamy nasz kalkulator
Problem: simulateHeavyOperation() zużywa dużo czasu
Krok 1. Profilujemy
W VisualVM widać, że niemal cały czas schodzi na Math.sqrt(i) wewnątrz pętli z 5_000_000 iteracji.
Krok 2. Optymalizujemy
Jeśli to tylko symulacja obciążenia — usuń ją lub zmniejsz liczbę iteracji.
Jeśli to realna logika biznesowa — zastanów się, czy można:
- Buforować wynik.
- Użyć szybszego algorytmu.
- Przenieść obliczenia do osobnego wątku (jeśli nie jest to krytyczne dla użytkownika).
Przykład optymalizacji:
private void simulateHeavyOperation() {
// Było 5_000_000, jest 100_000
for (int i = 0; i < 100_000; i++) {
Math.sqrt(i);
}
}
Krok 3. Sprawdzamy rezultat
Ponownie uruchamiamy profilowanie — program działa szybciej, obciążenie CPU spadło.
7. Wizualizacja: proces optymalizacji
flowchart TD
A[Uruchomienie aplikacji]
B["Profilowanie (VisualVM)"]
C[Identyfikacja wąskich gardeł]
D[Optymalizacja kodu]
E[Powtórne profilowanie]
F[Poprawa wydajności]
A --> B --> C --> D --> E --> F
E --> C
8. Typowe błędy przy profilowaniu i optymalizacji
Błąd nr 1: Optymalizacja „na oko”. Bardzo często programiści zaczynają zmieniać kod, nie mierząc, gdzie tak naprawdę leży problem. Efekt — dużo pracy, a rezultat minimalny.
Błąd nr 2: Profilowanie w „nierealnych” warunkach. Profilować trzeba na danych i z obciążeniem zbliżonym do produkcyjnego. Profilowanie „na pustym miejscu” może nie ujawnić prawdziwych problemów.
Błąd nr 3: Ignorowanie wycieków pamięci. Jeśli nie patrzeć na heap dump i nie analizować referencji, można długo nie zauważać, że program „puchnie” i wkrótce się wywróci.
Błąd nr 4: Pogoń za mikroskopijną optymalizacją. Nie warto spędzać dni na przyspieszaniu kodu, który zajmuje 0.1 % czasu pracy aplikacji. Najpierw — główne wąskie gardła.
Błąd nr 5: Nieuwzględnianie wątków i synchronizacji. W aplikacjach wielowątkowych problemy z wydajnością często wynikają nie z algorytmów, lecz z blokad i oczekiwania (synchronized, contention).
Błąd nr 6: Zapominanie o profilowaniu po zmianach. Po optymalizacji koniecznie sprawdź rezultat ponownie: czasem „optymalizacja” potrafi wręcz spowolnić działanie!
GO TO FULL VERSION