Управление памятью в Java и новые сборщики мусора

// Примерная зависимость времени паузы от размера кучи для разных GC
// Данные приближенные, на основе тестирования
// Размер кучи: 4 ГБ, 32 ГБ, 128 ГБ (в миллисекундах)
 
Serial GC:    [500,  4000,  16000]  // Линейный рост
Parallel GC:  [200,  1800,   7000]  // Линейный рост, но меньше
CMS GC:       [100,   800,   3500]  // Нелинейный рост
G1 GC:        [ 80,   300,   1200]  // Лучше масштабирование
ZGC:          [  2,     5,     10]  // Почти константа
Shenandoah:   [  2,     7,     15]  // Почти константа

// Сравнение относительной пропускной способности (throughput)
// за единицу берем пропускную способность Parallel GC
ParallelGC throughput = 1.0;  // Базовая линия
SerialGC throughput ≈ 0.85;   // Хуже из-за однопоточности
CMS throughput ≈ 0.90;        // Плата за конкурентность
G1 throughput ≈ 0.92;         // Почти как CMS
Shenandoah throughput ≈ 0.87; // Заметная плата за низкие задержки
ZGC throughput ≈ 0.90;        // Лучше чем у Shenandoah, но все еще ниже Parallel

// Пример простого бенчмарка для сравнения разных GC
public class GCBenchmark {
    private static final int ITERATIONS = 10_000_000;
    private static List<byte[]> temporaryStorage = new ArrayList<>();
    
    public static void main(String[] args) {
        long startTime = System.currentTimeMillis();
        
        for (int i = 0; i < ITERATIONS; i++) {
            // Создаем много короткоживущих объектов
            byte[] smallObject = new byte[100]; // 100 байт
            
            // Периодически сохраняем объект (имитация долгоживущих объектов)
            if (i % 10_000 == 0) {
                temporaryStorage.add(new byte[1024 * 10]); // 10 KB
            }
            
            // Периодически очищаем часть долгоживущих объектов
            if (i % 100_000 == 0 && !temporaryStorage.isEmpty()) {
                temporaryStorage.subList(0, temporaryStorage.size() / 2).clear();
            }
        }
        
        long endTime = System.currentTimeMillis();
        System.out.printf("Completed in %d ms, final storage size: %d items%n", 
                         (endTime - startTime), temporaryStorage.size());
    }
}

// Упрощенный пример настройки адаптивного управления ресурсами ZGC
// в файле конфигурации JVM
-XX:+UseZGC
-XX:+ZAdaptiveResourceControl
-XX:ZAdaptiveResourcePriority=latency // или throughput

// Новый флаг для микросервисной оптимизации 
-XX:+ZContainerAware
-XX:ZContainerResourceSensitivity=high // medium или low

// Структура цветного указателя ZGC (64-битная система)
// [0-17]  : Unused (предназначено для хеш-кода объекта)
// [18-45] : Смещение адреса в куче
// [46-63] : Метаданные ZGC и биты маркировки

// Настройка динамической регулировки
-XX:+UseShenandoahGC
-XX:+ShenandoahAdaptiveConcurrency
-XX:ShenandoahTargetCPUUtilization=0.7 // 70% для приложения, 30% для GC

// Включение расширенных метрик Shenandoah
-XX:+ShenandoahDetailedStatistics
-XX:+ShenandoahMetricsExport
-XX:ShenandoahMetricsPort=8099

// Упрощенная модель объекта Shenandoah
class ShenandoahObject {
    // Указатель на реальное местоположение объекта (добавляется Shenandoah)
    Object* forwardPtr;
    
    // Обычные поля объекта
    int field1;
    String field2;
    // ...
}

// Активация Balanced GC с основными настройками
-XX:+UseBalancedGC
-XX:BalancedLatencyTarget=5ms
-XX:BalancedThroughputTarget=0.95

// Пример использования аннотаций для Balanced GC
@GCCriticalPath(priority = GCPriority.HIGH)
public void processPayment() {
    // Код, требующий минимальных задержек
}
 
@GCFriendly
public void preprocessData() {
    // Код, который может быть прерван сборщиком
}

// Пример API для Region-Based Memory Management
try (MemoryRegion region = MemoryRegion.create()) {
    // Объекты, созданные внутри региона
    BigObject obj1 = region.allocate(BigObject.class);
    ComplexStructure obj2 = region.allocate(ComplexStructure.class);
    
    // ... работа с объектами ...
    
    // При выходе из блока try, все объекты в регионе 
    // будут автоматически освобождены
}

// Пример конфигурации PMM
-XX:+EnablePMM
-XX:PMMWindowSize=30s  // Размер окна для анализа тенденций
-XX:PMMPredictionConfidence=0.85  // Порог уверенности для предсказаний

// Базовая конфигурация для ZGC в приложении с высокими требованиями к латентности
-XX:+UseZGC
-Xms8g -Xmx8g  // Одинаковый мин. и макс. размер кучи снижает колебания производительности
-XX:+AlwaysPreTouch  // Предварительное выделение памяти для снижения латентности
-XX:+UseTransparentHugePages  // Оптимизация для Linux-систем
-XX:ZCollectionInterval=120  // Интервал между циклами сборки (в секундах)

// Конфигурация для приложения с высокой пропускной способностью
-XX:+UseParallelGC  // Все еще лучший выбор для максимальной пропускной способности
-Xms16g -Xmx16g
-XX:ParallelGCThreads=16  // Регулируем в зависимости от доступных ядер
-XX:+UseAdaptiveSizePolicy  // Автоматически настраивает размеры поколений

// Конфигурация для микросервиса в контейнере
-XX:+UseZGC
-XX:+ZGenerational  // Включаем генерационный ZGC для еще лучшей производительности
-XX:+UseContainerSupport  // JVM учитывает лимиты контейнера
-XX:MaxRAMPercentage=75.0  // Используем только 75% доступной памяти
-XX:ActiveProcessorCount=2  // Явно указываем количество процессоров для JVM

// Добавление агента для удаленного профилирования
-javaagent:/path/to/agent.jar
-Dcom.memory.agent.serviceName=payment-service
-Dcom.memory.agent.collectorUrl=http://metrics-collector:8080

// Проблемный код
public Response processLargeRequest(Request request) {
    // Request содержит большой JSON-массив
    List<Item> items = request.getItems();
    
    // Создаётся много временных объектов при обработке
    return items.stream()
                .map(this::processItem)
                .collect(Collectors.toList());
}
 
// Оптимизированная версия
public Response processLargeRequest(Request request) {
    List<Item> items = request.getItems();
    int size = items.size();
    
    // Предварительно выделяем место в списке
    List<ProcessedItem> result = new ArrayList<>(size);
    
    // Избегаем создания промежуточных коллекций
    for (Item item : items) {
        result.add(processItem(item));
    }
    
    return new Response(result);
}

// Получение heap dump при повышении потребления памяти выше порога
-XX:+HeapDumpOnOutOfMemoryError
-XX:HeapDumpPath=/path/to/dumps/
-XX:+ExitOnOutOfMemoryError  // В микросервисах часто предпочтительнее перезапустить контейнер
 
// Включение подробного логирования GC
-Xlog:gc*=debug:file=/logs/gc-%t.log:time,uptime,level,tags:filecount=10,filesize=100M

// Пример использования JCmd для создания heap dump в определённый момент
jcmd <pid> GC.heap_dump /path/to/dump1.hprof
 
// Через некоторое время:
jcmd <pid> GC.heap_dump /path/to/dump2.hprof
 
// Затем сравнение с помощью специализированных инструментов

// Проблемный код кэша с утечкой памяти
class LeakingCache<K, V> {
    private final Map<K, WeakReference<V>> cache = new HashMap<>();
    private final LinkedHashMap<K, Boolean> accessOrder = new LinkedHashMap<>(16, 0.75f, true);
    
    public V get(K key) {
        WeakReference<V> ref = cache.get(key);
        if (ref != null) {
            accessOrder.get(key);  // Обновляем порядок доступа, но сохраняем сильную ссылку на ключ
            return ref.get();
        }
        return null;
    }
}
 
// Исправленная версия
class FixedCache<K, V> {
    private final Map<K, V> cache = new LinkedHashMap<K, V>(16, 0.75f, true) {
        protected boolean removeEl******try(Map.Entry eldest) {
            return size() > MAX_SIZE;  // Явно ограничиваем размер
        }
    };
}

// Оптимальные настройки для контейнеризованного приложения
-XX:+UseZGC
-XX:+UseContainerSupport
-XX:MinRAMPercentage=50.0  // Минимум 50% доступной памяти
-XX:MaxRAMPercentage=80.0  // Максимум 80% доступной памяти
-XX:+ExitOnOutOfMemoryError  // Быстрый отказ для перезапуска контейнера

// Плохо
Map<Integer, Integer> map = new HashMap<>();
for (int i = 0; i < 1000; i++) {
    int value = i * 2;
    map.put(i, value);  // Каждый вызов создаёт два новых объекта Integer
}
 
// Лучше
// Использовать специализированные коллекции для примитивных типов
IntObjectMap<Integer> map = new IntObjectHashMap<>();
for (int i = 0; i < 1000; i++) {
    int value = i * 2;
    map.put(i, value);
}
 
// Или ещё лучше, если нужна карта примитив->примитив
IntIntMap map = new IntIntHashMap();
for (int i = 0; i < 1000; i++) {
    int value = i * 2;
    map.put(i, value);
}

// Плохо
List<String> names = new ArrayList<>();  // Начальная ёмкость по умолчанию - 10
for (User user : users) {  // users.size() может быть тысячи
    names.add(user.getName());
}
 
// Лучше
List<String> names = new ArrayList<>(users.size());  // Сразу выделяем нужную ёмкость
for (User user : users) {
    names.add(user.getName());
}

// Пример эффективного кэширования с ограничением размера и времени жизни
LoadingCache<String, UserProfile> userCache = Caffeine.newBuilder()
    .maximumSize(10_000)  // Максимум 10,000 записей
    .expireAfterWrite(Duration.ofMinutes(15))  // 15 минут до истечения срока
    .recordStats()  // Для мониторинга эффективности кэша
    .build(key -> userService.loadUserProfile(key));  // Функция загрузки

// Пример простого пула объектов
public class ByteArrayPool {
    private final Queue<byte[]> pool = new ConcurrentLinkedQueue<>();
    private final int bufferSize;
    
    public ByteArrayPool(int bufferSize, int initialSize) {
        this.bufferSize = bufferSize;
        for (int i = 0; i < initialSize; i++) {
            pool.offer(new byte[bufferSize]);
        }
    }
    
    public byte[] borrow() {
        byte[] buffer = pool.poll();
        return buffer != null ? buffer : new byte[bufferSize];
    }
    
    public void release(byte[] buffer) {
        if (buffer != null && buffer.length == bufferSize) {
            pool.offer(buffer);
        }
    }
}
 
// Использование
ByteArrayPool pool = new ByteArrayPool(8192, 100);
try (InputStream in = new FileInputStream(file)) {
    byte[] buffer = pool.borrow();
    try {
        int read;
        while ((read = in.read(buffer)) != -1) {
            // Обработка данных
        }
    } finally {
        pool.release(buffer);
    }
}

// Пример Value Type (синтаксис Java 2025)
value class Point {
    private final int x;
    private final int y;
    
    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }
    
    public int x() { return x; }
    public int y() { return y; }
}
 
// Использование
Point p = new Point(10, 20);  // Нет аллокации в куче

// Рекурсивная версия
public long fibonacci(int n) {
    if (n <= 1) return n;
    return fibonacci(n - 1) + fibonacci(n - 2);
}
 
// Итеративная версия, более эффективная по памяти
public long fibonacciIterative(int n) {
    if (n <= 1) return n;
    
    long fib1 = 0;
    long fib2 = 1;
    long result = 0;
    
    for (int i = 2; i <= n; i++) {
        result = fib1 + fib2;
        fib1 = fib2;
        fib2 = result;
    }
    
    return result;
}

// До оптимизации
public List<Transaction> processTransactions(String jsonData) {
    ObjectMapper mapper = new ObjectMapper();
    
    // Каждый вызов парсит JSON и создает множество объектов
    TransactionBatch batch = mapper.readValue(jsonData, TransactionBatch.class);
    
    return batch.getTransactions().stream()
                .filter(this::isValidTransaction)
                .map(this::enrichTransaction)
                .collect(Collectors.toList());
}
 
// После оптимизации
// Singleton ObjectMapper и повторное использование парсера
private static final ObjectMapper MAPPER = new ObjectMapper();
 
// Избегаем лишнего создания коллекций и промежуточных объектов
public List<Transaction> processTransactions(String jsonData) throws IOException {
    // Используем JsonParser напрямую для экономии памяти
    JsonParser parser = MAPPER.getFactory().createParser(jsonData);
    
    // Используем преаллокацию для результирующего списка
    List<Transaction> result = new ArrayList<>(estimateTransactionCount(jsonData));
    
    // Итеративное чтение документа без создания полного дерева объектов
    if (parser.nextToken() == JsonToken.START_OBJECT) {
        while (parser.nextToken() != JsonToken.END_OBJECT) {
            String fieldName = parser.getCurrentName();
            if ("transactions".equals(fieldName) && parser.nextToken() == JsonToken.START_ARRAY) {
                while (parser.nextToken() != JsonToken.END_ARRAY) {
                    Transaction tx = MAPPER.readValue(parser, Transaction.class);
                    if (isValidTransaction(tx)) {
                        result.add(enrichTransaction(tx));
                    }
                }
            }
        }
    }
    
    return result;
}

// Пример интеграции Micrometer для экспорта метрик GC
@Bean
public GarbageCollectionMetrics gcMetrics(MeterRegistry registry) {
    return new GarbageCollectionMetrics(registry, 
                                       Set.of("ZGC Cycles", "ZGC Pauses"), 
                                       StandardTags.MEMORY);
}
 
// Настройка алертов на аномальные паттерны GC
@Bean
public AlertingConfig gcAlertConfig() {
    return AlertingConfig.builder()
        .metric("jvm.gc.pause")
        .threshold(Duration.ofMillis(200))
        .windowSize(Duration.ofMinutes(5))
        .minViolationCount(3)
        .notificationChannel("slack-team-channel")
        .build();
}

-XX:+UseZGC
-XX:+ZGenerational
-XX:ConcGCThreads=6  // Примерно 1/4 от доступных ядер
-XX:ZCollectionInterval=5  // Частые короткие циклы сборки

-XX:+UseParallelGC
-XX:ParallelGCThreads=16
-XX:MaxGCPauseMillis=1000  // Допускаем паузы до 1 секунды для максимальной пропускной способности

-XX:+UseShenandoahGC
-XX:ShenandoahGCHeuristics=compact  // Агрессивное управление фрагментацией
-XX:MaxRAMPercentage=75.0

-XX:+UseZGC
-XX:+ZGenerational
-XX:+UnlockExperimentalVMOptions
-XX:+UseStringDeduplication  // Экономия памяти на строках

-XX:+UseShenandoahGC
-XX:ShenandoahGCHeuristics=adaptive
-XX:ShenandoahGuaranteedGCInterval=1000  // Гарантированный запуск GC каждую секунду