Что такое профилирование?

Профилирование

Профилирование (Profiling) — это процесс анализа выполнения программы для выявления узких мест, неэффективного использования ресурсов и проблем с производительностью. Профилировщик собирает информацию о времени выполнения, использовании памяти, количестве вызовов функций и других метриках во время работы приложения.

Основные концепции

Профилирование позволяет найти ответы на вопросы:

• Какие методы занимают больше всего времени?
• Где происходят утечки памяти?
• Какие объекты создаются чаще всего?
• Сколько раз вызывается определённый метод?
• Какие потоки потребляют больше всего CPU?

Типы профилирования:

• CPU профилирование - анализ времени выполнения
• Память профилирование - отслеживание использования памяти
• I/O профилирование - анализ операций ввода-вывода
• Блокировка профилирование - выявление deadlock и contention

Встроенные инструменты Java

1. JProfiler

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

public class ProfilingExample {
    public static void main(String[] args) {
        long startTime = System.currentTimeMillis();
        
        List<Integer> numbers = new ArrayList<>();
        for (int i = 0; i < 1_000_000; i++) {
            numbers.add(i);
        }
        
        // Дорогостоящая операция
        int sum = calculateSum(numbers);
        
        long endTime = System.currentTimeMillis();
        System.out.println("Время выполнения: " + (endTime - startTime) + " мс");
        System.out.println("Сумма: " + sum);
    }
    
    private static int calculateSum(List<Integer> numbers) {
        int sum = 0;
        for (int num : numbers) {
            sum += num;
        }
        return sum;
    }
}

2. JFR (Java Flight Recorder)

# Запуск приложения с JFR
java -XX:+UnlockCommercialFeatures -XX:+FlightRecorder -XX:StartFlightRecording=duration=60s,filename=recording.jfr MyApp

# Анализ результатов
jfp recording.jfr

Программное профилирование с использованием кода

public class SimpleProfiler {
    public static void main(String[] args) {
        // Профилирование CPU
        profileCPU();
        
        // Профилирование памяти
        profileMemory();
    }
    
    private static void profileCPU() {
        System.out.println("=== CPU Профилирование ===");
        
        long startTime = System.nanoTime();
        long startCPUTime = getThreadCPUTime();
        
        // Выполнение операции
        fibonacci(40);
        
        long endCPUTime = getThreadCPUTime();
        long endTime = System.nanoTime();
        
        System.out.println("Реальное время: " + (endTime - startTime) / 1_000_000 + " мс");
        System.out.println("CPU время: " + (endCPUTime - startCPUTime) / 1_000_000 + " мс");
    }
    
    private static void profileMemory() {
        System.out.println("\n=== Memory Профилирование ===");
        
        Runtime runtime = Runtime.getRuntime();
        
        long memBefore = runtime.totalMemory() - runtime.freeMemory();
        
        // Выделение памяти
        List<byte[]> list = new ArrayList<>();
        for (int i = 0; i < 1000; i++) {
            list.add(new byte[1024 * 1024]); // 1MB
        }
        
        long memAfter = runtime.totalMemory() - runtime.freeMemory();
        
        System.out.println("Память до: " + (memBefore / 1024 / 1024) + " MB");
        System.out.println("Память после: " + (memAfter / 1024 / 1024) + " MB");
        System.out.println("Использовано: " + ((memAfter - memBefore) / 1024 / 1024) + " MB");
    }
    
    private static long getThreadCPUTime() {
        return java.lang.management.ManagementFactory.getThreadMXBean()
            .getCurrentThreadCpuTime();
    }
    
    private static long fibonacci(int n) {
        if (n <= 1) return n;
        return fibonacci(n - 1) + fibonacci(n - 2);
    }
}

Декоратор для профилирования методов

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class ProfilingProxy implements InvocationHandler {
    private Object target;
    
    public ProfilingProxy(Object target) {
        this.target = target;
    }
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        long startTime = System.nanoTime();
        
        try {
            return method.invoke(target, args);
        } finally {
            long endTime = System.nanoTime();
            long duration = (endTime - startTime) / 1_000_000; // в миллисекундах
            System.out.printf("[PROFILE] %s.%s выполнена за %d мс\n",
                target.getClass().getSimpleName(),
                method.getName(),
                duration);
        }
    }
    
    public static <T> T profile(T target, Class<T> interfaceClass) {
        return (T) Proxy.newProxyInstance(
            interfaceClass.getClassLoader(),
            new Class[]{interfaceClass},
            new ProfilingProxy(target)
        );
    }
}

// Использование
interface Calculator {
    int add(int a, int b);
}

class CalculatorImpl implements Calculator {
    @Override
    public int add(int a, int b) {
        return a + b;
    }
}

public class Main {
    public static void main(String[] args) {
        Calculator calc = ProfilingProxy.profile(
            new CalculatorImpl(),
            Calculator.class
        );
        
        calc.add(5, 3); // Выведет время выполнения
    }
}

Современные инструменты профилирования

JProfiler - профессиональный инструмент:

jprofile MyApplication

YourKit Java Profiler - с визуализацией:

java -agentpath=/path/to/yjpagent.so MyApplication

Async Profiler - низкие overhead:

async-profiler.sh -d 30 -f flamegraph.html jps

Практический пример: анализ производительности

public class PerformanceAnalyzer {
    public static void main(String[] args) {
        analyzeAlgorithms();
    }
    
    static void analyzeAlgorithms() {
        int[] sizes = {1000, 10000, 100000};
        
        for (int size : sizes) {
            int[] arr = generateArray(size);
            
            long t1 = System.nanoTime();
            bubbleSort(arr.clone());
            long time1 = System.nanoTime() - t1;
            
            long t2 = System.nanoTime();
            quickSort(arr.clone(), 0, arr.length - 1);
            long time2 = System.nanoTime() - t2;
            
            System.out.printf("Размер: %d | BubbleSort: %.2f мс | QuickSort: %.2f мс\n",
                size, time1 / 1_000_000.0, time2 / 1_000_000.0);
        }
    }
    
    static void bubbleSort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - i - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }
    
    static void quickSort(int[] arr, int low, int high) {
        if (low < high) {
            int pi = partition(arr, low, high);
            quickSort(arr, low, pi - 1);
            quickSort(arr, pi + 1, high);
        }
    }
    
    static int partition(int[] arr, int low, int high) {
        int pivot = arr[high];
        int i = low - 1;
        for (int j = low; j < high; j++) {
            if (arr[j] < pivot) {
                i++;
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
        int temp = arr[i + 1];
        arr[i + 1] = arr[high];
        arr[high] = temp;
        return i + 1;
    }
    
    static int[] generateArray(int size) {
        int[] arr = new int[size];
        for (int i = 0; i < size; i++) {
            arr[i] = (int)(Math.random() * 10000);
        }
        return arr;
    }
}

Когда использовать профилирование

• Выявление узких мест в критичных по производительности участках
• Отладка утечек памяти
• Оптимизация алгоритмов
• Мониторинг production приложений
• Сравнение различных реализаций

Профилирование — важный инструмент для создания высокопроизводительных Java приложений и успешной оптимизации кода в production среде.