Что отвечает за очистку памяти

Что отвечает за очистку памяти в Java?

Очистка памяти в Java — это процесс автоматического удаления объектов, которые больше не используются программой. За это отвечает Garbage Collector (GC) — критически важный компонент Java Runtime Environment (JRE).

Основной концепт: Garbage Collection

Garbage Collection (GC) — это автоматический процесс, который:

1. Находит объекты, которые больше не нужны программе
2. Освобождает память, которую они занимали
3. Делает эту память доступной для новых объектов

Это основная причина, почему Java разработчики не должны вручную удалять объекты (как в C++).

Как Java определяет, что объект "мусор"?

Концепция: Reachability (Достижимость)

Объект считается "живым" (reachable), если есть хотя бы одна ссылка на него из корневых объектов.

Корневые объекты:

1. Локальные переменные в стеке (stack)
2. Статические поля класса
3. Активные потоки
4. JNI ссылки (код на C/C++)

public class GCExample {
    public static void main(String[] args) {
        Object obj1 = new Object();  // ✓ Reachable (есть ссылка obj1)
        Object obj2 = new Object();  // ✓ Reachable (есть ссылка obj2)
        
        obj1 = null;  // Теперь obj1 становится UNREACHABLE
        //  ↑ GC может удалить этот объект
        
        obj2 = obj1;  // obj2 также становится null
        // Теперь оба объекта UNREACHABLE
    }
}

// Visual:
// ┌─────────────────────────┐
// │      Java Heap          │
// │                         │
// │  ┌───────────────────┐  │
// │  │   Object #1       │  │ ← UNREACHABLE (GC удалит)
// │  │ (New String(100)) │  │
// │  └───────────────────┘  │
// │                         │
// │  ┌───────────────────┐  │
// │  │   Object #2       │  │ ← REACHABLE
// │  │ (Referenced: str) │←─┼─── str (stack)
// │  └───────────────────┘  │
// │                         │
// └─────────────────────────┘

Граф ссылок (Reference Graph)

public class Person {
    private String name;
    private List<String> emails;
}

Person person = new Person();  // person — корневая ссылка
person.name = "John";          // String также reachable
person.emails = new ArrayList<>();  // List также reachable
person.emails.add("john@example.com");  // String также reachable

// Граф достижимости:
// main (корень)
//  ↓
// person → Person объект
//           ├→ name → "John"
//           └→ emails → ArrayList
//               └→ "john@example.com"

// Если person = null:
// Все объекты (Person, "John", ArrayList, email string) становятся UNREACHABLE
// GC может удалить их все

Структура Java Heap

Память Java разделена на несколько областей:

┌──────────────────────────────────────────┐
│           Java Heap Memory               │
├──────────────────────────────────────────┤
│                                          │
│  ┌─────────────────────────────────────┐ │
│  │  Young Generation (80-90%)           │ │
│  │                                     │ │
│  │  ┌──────────────┬──────────────────┐│ │
│  │  │   Eden Space │  Survivor Spaces ││ │
│  │  │ (новые обьекты) │ (пережившие)││ │
│  │  └──────────────┴──────────────────┘│ │
│  └─────────────────────────────────────┘ │
│                                          │
│  ┌─────────────────────────────────────┐ │
│  │  Old Generation (10-20%)             │ │
│  │ (долгоживущие объекты)              │ │
│  └─────────────────────────────────────┘ │
│                                          │
│  ┌─────────────────────────────────────┐ │
│  │  Permanent Generation (Java 7)       │ │
│  │  / Metaspace (Java 8+)               │ │
│  │  (классы, методы, строки)            │ │
│  └─────────────────────────────────────┘ │
│                                          │
└──────────────────────────────────────────┘

Типы Garbage Collectors

1. Serial GC (самый простой)

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

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

• Использует один поток для GC
• Приостанавливает ВСЕ потоки приложения (Stop-the-World)
• Самый медленный, но с минимальным overhead'ом
• Хорошо для small heap (<100MB) и desktop приложений

Процесс:

Время →
┌─────────────────────────────────────────────┐
│ App working ... App working ... GC pause ★ │ GC pause (500ms)
│ App working ... App working ... GC pause ★ │ GC pause (300ms)
│                                             │
│ ★ PAUSE: GC лочит всех (Stop-the-World)    │
└─────────────────────────────────────────────┘

2. Parallel GC (многопоточный)

// Запуск:
// java -XX:+UseParallelGC MyApplication
// java -XX:ParallelGCThreads=4 MyApplication

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

• Использует несколько потоков для GC параллельно
• Но всё ещё Stop-the-World
• Лучше для многоядерных систем
• Хорошо для batch processing и server приложений

3. CMS GC (Concurrent Mark Sweep)

// Запуск:
// java -XX:+UseConcMarkSweepGC MyApplication

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

• Работает почти одновременно с приложением
• Минимизирует паузы (обычно 10-100ms)
• Два режима:
  • Concurrent Mark: отмечает живые объекты (параллельно с приложением)
  • Sweep: удаляет мёртвые объекты

Время →
┌─────────────────────────────────────────────┐
│ App running...  GC mark... App running...  │ Практически нет пауз
│ App running...  GC sweep.. App running...  │ GC работает "в фоне"
└─────────────────────────────────────────────┘

4. G1GC (Garbage First) — рекомендуется современным

// Запуск:
// java -XX:+UseG1GC MyApplication
// java -XX:MaxGCPauseMillis=200 MyApplication

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

• Делит Heap на множество малых регионов (regions)
• Сортирует регионы по утечкам
• Сначала собирает "мусорные" регионы
• Предсказуемые паузы (обычно 200ms)
• Лучший выбор для большинства приложений

G1 Heap (50+ regions):
┌────────────────────────────────────┐
│ [young] [young] [old] [free]      │
│ [young] [old]   [old] [free]      │
│ [young] [young] [old] [free]      │
│ ...                               │
└────────────────────────────────────┘

GC собирает сначала молодые с большим мусором

5. ZGC (Ultra-Low Latency)

// Запуск (Java 11+):
// java -XX:+UseZGC MyApplication

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

• Паузы < 10ms даже с терабайтом Heap
• Новая технология (Java 11+)
• Отличный для real-time приложений
• Требует JDK 11+

6. Shenandoah GC

// Запуск:
// java -XX:+UseShenandoahGC MyApplication

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

• Похож на ZGC
• Очень низкие паузы
• Поддержка OpenJDK

Когда вызывается GC?

Automatic Triggers:

// Когда Young Generation заполняется
Object[] array = new Object[1000000];
// Хип заполнился → GC работает

// Когда Old Generation заполняется
List<Object> cache = new ArrayList<>();
for (int i = 0; i < 1000000; i++) {
    cache.add(new Object());
}
// Old Generation заполнился → Full GC

Manual Trigger (НЕ рекомендуется):

System.gc();  // ❌ Просит GC, но не гарантирует
Runtime.getRuntime().gc();  // ❌ То же самое

// ПРОБЛЕМА: Это может сильно замедлить приложение
// Используй ТОЛЬКО если точно знаешь, что делаешь

Практический пример: Мониторинг GC

JVM flags для отладки GC:

# Выводить информацию о GC
java -Xmx512m -Xms512m \
     -XX:+PrintGCDetails \
     -XX:+PrintGCDateStamps \
     -XX:+UseG1GC \
     MyApplication

# Результат:
# [2023-10-15T10:30:45.123+0000]: [GC (G1 Evacuation Pause)
# [PSYoungGen: 100M->10M(120M)] 300M->210M(500M)
# Time: 45.234 ms

Программный мониторинг:

import java.lang.management.*;

public class GCMonitor {
    public static void main(String[] args) {
        // Получить информацию о GC
        List<GarbageCollectorMXBean> gcBeans = 
            ManagementFactory.getGarbageCollectorMXBeans();
        
        for (GarbageCollectorMXBean bean : gcBeans) {
            System.out.println("GC Name: " + bean.getName());
            System.out.println("Collection Count: " + bean.getCollectionCount());
            System.out.println("Collection Time (ms): " + bean.getCollectionTime());
        }
        
        // Информация о памяти
        MemoryMXBean memoryBean = ManagementFactory.getMemoryMXBean();
        MemoryUsage heapMemory = memoryBean.getHeapMemoryUsage();
        
        System.out.println("\nHeap Memory:");
        System.out.println("Init: " + heapMemory.getInit() / (1024*1024) + "MB");
        System.out.println("Used: " + heapMemory.getUsed() / (1024*1024) + "MB");
        System.out.println("Max: " + heapMemory.getMax() / (1024*1024) + "MB");
        System.out.println("Committed: " + heapMemory.getCommitted() / (1024*1024) + "MB");
    }
}

Проблемы и их решение

1. OutOfMemoryError: Java Heap Space

// Проблема: Heap заполнен, нет места для новых объектов
List<Object> list = new ArrayList<>();
while (true) {
    list.add(new byte[1000000]);  // 1MB объект
    // Через какое-то время: OutOfMemoryError
}

// Решение:
// 1. Увеличить Heap
java -Xmx1024m MyApplication

// 2. Найти memory leak (объекты, которые не удаляются)
// Использовать heap dump: jmap -dump:live,format=b,file=dump.bin <pid>

// 3. Оптимизировать код (удаления ненужные ссылки)
list = null;  // Освобождаем ссылку

2. GC Overhead Limit Exceeded

Проблема: GC занимает >98% времени, не освобождая память
(обычно это мертвый цикл с утечкой памяти)

3. Memory Leak

// Пример утечки памяти:
public class MemoryLeakExample {
    private static List<Object> cache = new ArrayList<>();
    
    public void addToCache(Object obj) {
        cache.add(obj);  // Объекты никогда не удаляются
    }
}

// Решение:
// 1. Используй WeakHashMap или WeakReference для кэша
import java.util.WeakHashMap;

Map<String, Object> cache = new WeakHashMap<>();  // Объекты удаляются при GC

// 2. Или явно удали старые объекты
if (cache.size() > MAX_SIZE) {
    cache.clear();
}

Выбор GC для разных сценариев

Итоги

1. GC (Garbage Collector) автоматически удаляет unreachable объекты
2. Reachability — ключ к пониманию: объект живой если к нему есть ссылка
3. Heap разделён на Young, Old, Metaspace
4. Выбор GC зависит от приложения: G1GC — хороший выбор для большинства
5. Мониторь GC через logs и tools (jstat, VisualVM, JProfiler)
6. Помни про паузы — GC приостанавливает приложение (даже современные GCs)
7. Memory leaks — худший враг, используй tools для их обнаружения