CodeGym /Kursy /JAVA 25 SELF /Profilowanie i optymalizacja kodu: narzędzia i podejścia

Profilowanie i optymalizacja kodu: narzędzia i podejścia

JAVA 25 SELF
Poziom 63, Lekcja 4
Dostępny

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ę?

  1. Skompiluj i uruchom aplikację.
  2. Otwórz VisualVM (jvisualvm).
  3. Znajdź swój proces (zwykle po nazwie klasy Main).
  4. Przejdź do zakładki CPU Profiler i kliknij Start.
  5. Pozwól programowi popracować (albo naciśnij „wolny” przycisk jeszcze raz).
  6. 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!

1
Zadanie
JAVA 25 SELF, poziom 63, lekcja 4
Niedostępne
Eko-aktywista
Eko-aktywista
1
Zadanie
JAVA 25 SELF, poziom 63, lekcja 4
Niedostępne
Kapitan Kirk
Kapitan Kirk
1
Ankieta/quiz
Logowanie, poziom 63, lekcja 4
Niedostępny
Logowanie
Logowanie, monitoring i profilowanie
Komentarze
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION