Как происходит ограничение оперативной памяти

# Как происходит ограничение оперативной памяти в Java

Ограничение оперативной памяти в Java управляется JVM (Java Virtual Machine) и работает на нескольких уровнях. Это не просто лимит ОС, а сложная система управления памятью.

1. Уровни ограничения памяти

Уровень 1: Операционная система

# Физическая память компьютера
# На Linux: free -h
# Вывод: Mem:  16Gi used, 4Gi free

Уровень 2: JVM heap + non-heap

┌─────────────────────────────────────┐
│  Java Process Memory (process limit)│
├─────────────────────────────────────┤
│  JVM Heap (где живут объекты)      │ <- -Xmx управляет
│  ├─ Young Generation               │
│  │  ├─ Eden                        │
│  │  ├─ Survivor 1                  │
│  │  └─ Survivor 2                  │
│  └─ Old Generation                 │
├─────────────────────────────────────┤
│  Metaspace (классы, константы)    │ <- -XX:MetaspaceSize управляет
│  Stack (локальные переменные)     │ <- -Xss управляет
│  Code Cache (скомпилированный код)│
│  Direct Memory (NIO buffers)      │
│  Memory Mapped Files              │
└─────────────────────────────────────┘

2. Основные флаги JVM для ограничения памяти

# Стартовая память Heap
java -Xms512m MyApp

# Максимальная память Heap (ОСНОВНОЙ ЛИМИТ)
java -Xmx2g MyApp

# Размер Stack (за поток)
java -Xss1m MyApp

# Максимальный размер Metaspace
java -XX:MetaspaceSize=128m -XX:MaxMetaspaceSize=256m MyApp

# Максимум для Direct Memory (NIO)
java -XX:MaxDirectMemorySize=1g MyApp

# Все вместе (типичная production конфигурация)
java -Xms4g -Xmx4g -Xss1m -XX:MaxMetaspaceSize=256m -XX:MaxDirectMemorySize=512m MyApp

3. Как JVM управляет Heap памятью

Механизм работы

// 1. Объект создаётся в Eden (быстрый allocation)
User user = new User("John");  // ~40 bytes

// 2. Eden заполняется
// User1, User2, User3, ..., User100000

// 3. Eden переполняется → Garbage Collection (Minor GC)
// ┌─────────────┬──────────┬──────────┐
// │   Eden      │ Survivor1│ Survivor2│
// ├─────────────┼──────────┼──────────┤
// │  [Объекты]  │          │          │ <- Начальное состояние
// └─────────────┴──────────┴──────────┘
//
// GC: живые объекты копируются в Survivor1
// ┌─────────────┬──────────┬──────────┐
// │   cleared   │ [объекты]│          │ <- После Minor GC
// └─────────────┴──────────┴──────────┘

Процесс Garbage Collection

Отслеживание памяти в JVM:

1. ALLOCATION (Выделение памяти)
   User user = new User("John");
   ↓
   Выделяем память в Eden
   Увеличиваем heap usage: 100MB → 140MB

2. USAGE (Использование)
   System.out.println(user.getName());
   ↓
   Объект активно используется

3. COLLECTION (Сборка мусора)
   if (heapUsed > heapMax) {
       // или if (Eden full)
       triggerGC();
   }
   ↓
   GC ищет неживые объекты через GC Roots
   (локальные переменные, static поля, active threads)

4. CLEANUP (Очистка)
   Удаляет неживые объекты
   Переносит живые объекты
   Освобождает память

4. Практический пример ограничения памяти

public class MemoryLimitExample {
    public static void main(String[] args) {
        // Запущено с: java -Xmx256m MemoryLimitExample
        
        long maxMemory = Runtime.getRuntime().maxMemory();  // 256MB
        long totalMemory = Runtime.getRuntime().totalMemory();  // текущий heap
        long freeMemory = Runtime.getRuntime().freeMemory();   // свободно
        
        System.out.println("Max memory: " + maxMemory / 1024 / 1024 + " MB");  // 256
        System.out.println("Total memory: " + totalMemory / 1024 / 1024 + " MB");  // ~100
        System.out.println("Free memory: " + freeMemory / 1024 / 1024 + " MB");  // ~90
        
        // Пытаемся выделить 300MB
        List<byte[]> list = new ArrayList<>();
        try {
            for (int i = 0; i < 300; i++) {
                list.add(new byte[1024 * 1024]);  // 1MB каждый
                System.out.println("Allocated: " + i + " MB");
            }
        } catch (OutOfMemoryError e) {
            System.err.println("OutOfMemoryError! Превышен лимит heap: 256MB");
            // Выбросится на ~256MB вместо 300MB
        }
    }
}

5. Что происходит при превышении лимита

public class OutOfMemoryDemo {
    public static void main(String[] args) {
        // java -Xmx64m OutOfMemoryDemo
        
        List<byte[]> leakyList = new ArrayList<>();
        
        while (true) {
            byte[] chunk = new byte[10_000_000];  // 10MB
            leakyList.add(chunk);
            // Утечка памяти: объекты никогда не удаляются
        }
        // Вывод:
        // Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
        // at OutOfMemoryDemo.main(OutOfMemoryDemo.java:8)
    }
}

Типы OutOfMemoryError

1. "Java heap space" — исчерпана Heap память
   Причина: утечка памяти, очень много объектов
   
2. "PermGen space" (Java 7) / "Metaspace" (Java 8+)
   Причина: слишком много классов загружено
   Решение: увеличить -XX:MaxMetaspaceSize
   
3. "GC overhead limit exceeded"
   Причина: GC тратит >98% времени на очистку <2% памяти
   Решение: увеличить heap или найти утечку
   
4. "Direct buffer memory"
   Причина: исчерпана Direct Memory (NIO буферы)
   Решение: увеличить -XX:MaxDirectMemorySize

6. Контроль за использованием памяти

# Посмотреть использование памяти процессом
jps              # Найти PID Java процесса
jmap -heap <pid> # Подробная информация о heap
jhat dump.bin    # Анализировать heap dump

# Создать heap dump при OutOfMemoryError
java -XX:+HeapDumpOnOutOfMemoryError \
     -XX:HeapDumpPath=/tmp/heap.bin \
     -Xmx256m MyApp

# Мониторинг в real-time
jconsole <pid>   # Графический интерфейс
jstat -gc <pid> 1000  # Каждую секунду

Пример: Мониторинг памяти

public class MemoryMonitor implements Runnable {
    @Override
    public void run() {
        while (true) {
            Runtime runtime = Runtime.getRuntime();
            long total = runtime.totalMemory();
            long free = runtime.freeMemory();
            long used = total - free;
            long max = runtime.maxMemory();
            
            System.out.printf(
                "Memory: Used=%dMB, Free=%dMB, Max=%dMB, Usage=%.1f%%\n",
                used / 1024 / 1024,
                free / 1024 / 1024,
                max / 1024 / 1024,
                (used * 100.0) / max
            );
            
            try {
                Thread.sleep(5000);  // каждые 5 сек
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }
}

7. Оптимизация использования памяти

// ❌ Плохо: создаёт 1000 String объектов
List<String> strings = new ArrayList<>();
for (int i = 0; i < 1000; i++) {
    strings.add(new String("Item " + i));
}

// ✅ Хорошо: переиспользуем StringBuilder
List<String> strings = new ArrayList<>(1000);
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 1000; i++) {
    strings.add(sb.append("Item ").append(i).toString());
    sb.setLength(0);  // очистить для переиспользования
}

8. Выбор правильного размера Heap

# Для микросервисов:
java -Xms512m -Xmx512m App.jar

# Для приложения с кэшем:
java -Xms2g -Xmx4g App.jar

# Для больших batch-обработок:
java -Xms8g -Xmx16g App.jar

# Правило: Xms == Xmx (избегаем resize во время работы)

Итог

Ограничение памяти в Java работает через:

1. Флаги JVM (-Xmx для максимума Heap)
2. Garbage Collector (автоматически удаляет неживые объекты)
3. Мониторинг и контроль (знать текущее использование)
4. Graceful handling (обрабатывать OutOfMemoryError)

Ключевой момент: когда heap достигает -Xmx, JVM больше не может выделять память для новых объектов → выбрасывается OutOfMemoryError.