Какие знаешь виды Garbage Collectors?

Виды Garbage Collectors в Java

Garbage Collector (GC) — это механизм автоматического управления памятью в Java, который избавляет программистов от необходимости ручного освобождения памяти. Существует несколько поколений GC с различными алгоритмами и характеристиками.

1. Serial GC

Самый простой и старый сборщик мусора.

Характеристики:

• Использует один поток для сборки мусора
• Все приложение останавливается (Stop-The-World pause) во время GC
• Лучше всего для однопоточных приложений и small heaps

// Запуск с Serial GC
// java -XX:+UseSerialGC Application

public class SerialGCExample {
    public static void main(String[] args) {
        // Во время GC приложение полностью останавливается
        for (int i = 0; i < 1000000; i++) {
            new Object(); // создаём объекты для сборки
        }
    }
}

Плюсы:

• Простой в реализации
• Хорошо работает на small heaps

Минусы:

• Долгие pause times (может быть несколько секунд)
• Неприемлем для real-time приложений
• Не использует многоядерные процессоры

2. Parallel GC (Throughput Collector)

Многопоточный сборщик, ориентирован на пропускную способность.

// Запуск с Parallel GC (по умолчанию в Java 8)
// java -XX:+UseParallelGC Application
// java -XX:ParallelGCThreads=4 Application

public class ParallelGCExample {
    public static void main(String[] args) {
        // Несколько потоков сразу собирают мусор
        for (int i = 0; i < 10000000; i++) {
            new Object();
        }
        
        // Общая пропускная способность выше,
        // чем Serial GC, но pause times всё ещё заметны
    }
}

Характеристики:

• Использует несколько потоков для сборки
• Всё приложение остаётся остановленным во время GC
• Параллельно собирает мусор в молодом и старом поколении

Плюсы:

• Высокая пропускная способность (throughput)
• Хорошо для batch-обработки
• Использует многоядерные процессоры

Минусы:

• Pause times всё ещё значительны (сотни миллисекунд)
• Неприемлем для latency-sensitive приложений

3. CMS GC (Concurrent Mark Sweep)

Дизайн на минимизацию pause times для старого поколения.

// Запуск с CMS GC (deprecated в Java 9)
// java -XX:+UseConcMarkSweepGC Application

public class CMSGCExample {
    public static void main(String[] args) {
        // Большинство сборки мусора происходит параллельно с приложением
        // Pause times значительно меньше чем Parallel GC
        
        for (int i = 0; i < 10000000; i++) {
            new Object();
        }
    }
}

Характеристики:

• Concurrent — большая часть работы делается во время работы приложения
• Низкие pause times для старого поколения
• Сложный алгоритм с multiple phases (initial mark, concurrent mark, remark, sweep)

Плюсы:

• Низкие pause times (десятки миллисекунд)
• Хорошо для latency-critical приложений

Минусы:

• Фрагментация памяти (нет compaction)
• CPU overhead из-за concurrent работы
• Может привести к Out-of-Memory (OOM) во время concurrent работы
• Deprecated в Java 9

4. G1GC (Garbage First)

Современный сборщик, разработан для больших heaps.

// Запуск с G1GC (по умолчанию в Java 9+)
// java -XX:+UseG1GC -Xmx4g Application

public class G1GCExample {
    public static void main(String[] args) {
        // G1 делит heap на regions
        // Собирает мусор из регионов с самым большим мусором
        // Predictable pause times
        
        for (int i = 0; i < 100000000; i++) {
            new Object();
        }
    }
}

Характеристики:

• Делит heap на regions (по умолчанию 2048 регионов)
• Concurrent и incremental сборка мусора
• Predictable pause times (обычно 200ms)
• Компактирует память на лету

Алгоритм:

1. Marking — параллельно отмечает live объекты
2. Remark — синхронизирует изменения (Stop-The-World)
3. Collection — собирает мусор из регионов с лучшим ratio (Garbage First)

// Туниинг G1GC
// java -XX:+UseG1GC \
//      -XX:MaxGCPauseMillis=200 \  // целевой pause time
//      -XX:G1HeapRegionSize=16m \  // размер региона
//      -Xmx4g Application

public class G1Tuning {
    public static void main(String[] args) {
        // G1 автоматически настраивает себя
        // Но можно контролировать pause time target
    }
}

Плюсы:

• Predictable pause times
• Хорошо масштабируется (heaps 10GB+)
• Concurrent работа снижает CPU overhead
• Автоматическое компактирование

Минусы:

• Более сложный, медленнее на small heaps
• Overhead на регионы и сборку информации

5. ZGC (Z Garbage Collector)

Ультра-низкие pause times (< 10ms).

// Запуск с ZGC (Java 11+, experimental)
// java -XX:+UseZGC -Xmx4g Application
// java -XX:+UnlockExperimentalVMOptions -XX:+UseZGC Application

public class ZGCExample {
    public static void main(String[] args) {
        // ZGC работает по большей части concurrent
        // Pause times < 10ms даже с heaps несколько TB
        
        for (int i = 0; i < 100000000; i++) {
            new Object();
        }
    }
}

Характеристики:

• Concurrent и incremental
• Colored pointers для отслеживания объектов
• Pause times < 10ms независимо от heap size
• Работает с heaps до нескольких TB

// Выбор ZGC для высоконагруженных систем
// java -XX:+UnlockExperimentalVMOptions \
//      -XX:+UseZGC \
//      -XX:ConcGCThreads=8 \  // concurrent threads
//      -XX:ParallelGCThreads=8 \ // parallel threads
//      -Xmx16g Application

Плюсы:

• Экстремально низкие pause times
• Масштабируется на very large heaps
• Concurrent работа

Минусы:

• Экспериментальный (но становится стабильным в новых Java versions)
• Требует Java 11+
• Больший memory overhead

6. Shenandoah GC

Ещё один сборщик с минимальными pause times (Java 12+).

// Запуск с Shenandoah GC
// java -XX:+UnlockExperimentalVMOptions \
//      -XX:+UseShenandoahGC Application

public class ShenandoahExample {
    public static void main(String[] args) {
        // Concurrent evacuation без copy-on-write
        // Pause times < 10ms
        
        for (int i = 0; i < 100000000; i++) {
            new Object();
        }
    }
}

Характеристики:

• Concurrent evacuation
• Pause times < 10ms
• Работает с heaps любого размера

Плюсы:

• Низкие pause times
• Хороший throughput

Минусы:

• Red pill GC (JDK-specific)
• Требует OpenJDK

7. Epsilon GC

Тривиальный сборщик — вообще не собирает мусор.

// Запуск с Epsilon GC (Java 11+)
// java -XX:+UnlockExperimentalVMOptions -XX:+UseEpsilonGC Application

public class EpsilonGCExample {
    public static void main(String[] args) {
        // Не выполняет сборку мусора вообще
        // Используется для тестирования и низколатентных операций
        
        for (int i = 0; i < 100000000; i++) {
            new Object();
        }
        // Heap будет заполняться, пока не произойдёт OutOfMemoryError
    }
}

Применение:

• Тестирование (отключить влияние GC на результаты)
• Очень короткоживущие приложения
• Microbenchmarking

Сравнение Garbage Collectors

Выбор GC для приложения

// Высокая пропускная способность (batch processing)
// java -XX:+UseParallelGC Application

// Низкие pause times (web applications)
// java -XX:+UseG1GC -XX:MaxGCPauseMillis=200 Application

// Экстремально низкие pause times (financial systems)
// java -XX:+UnlockExperimentalVMOptions -XX:+UseZGC Application

// Мониторинг GC
// java -XX:+PrintGCDetails -XX:+PrintGCDateStamps -Xloggc:gc.log Application

Итого

Serial GC — простой, для small heaps

Parallel GC — высокий throughput, но долгие pauses

CMS GC — низкие pauses, deprecated

G1GC — современный стандарт, предсказуемые pauses

ZGC/Shenandoah — экстремально низкие pauses для критичных систем

Выбор GC должен основываться на требованиях приложения: throughput vs latency.