Что хранится в JVM?

Что хранится в JVM?

JVM (Java Virtual Machine) — это виртуальная машина, которая выполняет Java-код. Она хранит и управляет различными типами данных и информации. Понимание этого критично для оптимизации производительности и отладки приложений.

Основные компоненты памяти JVM

1. Heap (Куча)

Это основная область памяти для хранения объектов:

public class HeapExample {
    public static void main(String[] args) {
        // person и person2 хранятся в stack,
        // объекты Person хранятся в heap
        Person person = new Person("John", 30);
        Person person2 = person;
        
        // person.address указывает на объект String в heap
        person.address = "New York";
    }
}

class Person {
    String name;      // ссылка на String в heap
    int age;         // примитив, хранится в самом объекте
    String address;  // ссылка на String в heap
}

Особенности Heap:

• Разделяется между всеми потоками
• Управляется Garbage Collector (автоматическое удаление неиспользуемых объектов)
• Если кончается память в heap — выбрасывается OutOfMemoryError: Java heap space
• Может быть увеличена параметром -Xmx при запуске JVM

2. Stack (Стек)

Хранит примитивные значения и ссылки на объекты (но не сами объекты):

public class StackExample {
    public static void main(String[] args) {
        int age = 30;                    // значение 30 в stack
        String name = "John";            // ссылка на String в stack,
                                         // сам String в heap
        double salary = 50000.50;        // значение в stack
        
        Person person = new Person();    // ссылка person в stack,
                                         // объект Person в heap
    }
}

Особенности Stack:

• Каждый поток имеет свой stack
• LIFO (Last In First Out) структура
• Локальные переменные хранятся здесь
• Быстрее, чем heap
• Если переполнится — StackOverflowError
• Память автоматически освобождается при выходе из scope

3. Method Area (область методов)

Хранит информацию о классах, методах, константах:

public class MethodAreaExample {
    private static final String CONSTANT = "Hello"; // в Method Area
    private static int counter = 0;                  // в Method Area
    
    public void method1() {                          // информация о методе
        // код метода хранится в Method Area
    }
}

Что хранится в Method Area:

• Структура классов (fields, methods, constructors)
• Байтекод методов
• Статические переменные
• Пулы константных данных (constant pools)
• Runtime constant pool

В Java 8+ это называется Metaspace (хранится в native memory, не в heap).

Типы данных в JVM

Примитивные типы (в stack)

public class PrimitiveTypes {
    byte age = 25;           // 1 byte
    short year = 2024;       // 2 bytes
    int count = 1000000;     // 4 bytes
    long distance = 123456L; // 8 bytes
    float pi = 3.14f;        // 4 bytes
    double e = 2.71828;      // 8 bytes
    boolean flag = true;      // 1 bit (обычно 1 byte на JVM)
    char symbol = 'A';       // 2 bytes (UTF-16)
}

Ссылочные типы (ссылка в stack, объект в heap)

public class ReferenceTypes {
    String text = "Hello";        // ссылка на String object в heap
    int[] numbers = {1, 2, 3};    // ссылка на массив в heap
    Person person = new Person(); // ссылка на объект Person в heap
    List<String> list = new ArrayList<>(); // ссылка на List в heap
}

Специальные области памяти

Program Counter (PC) Register

public class PCRegisterExample {
    public static void main(String[] args) {
        method1(); // PC Register показывает адрес текущей инструкции
        method2(); // PC Register обновляется
    }
    
    static void method1() {
        // инструкция 1
        // инструкция 2
    }
    
    static void method2() {
        // инструкция 3
    }
}

Это небольшой регистр, который содержит адрес текущей выполняемой JVM инструкции.

Native Method Stack

Хранит информацию о native методах (написанных на C/C++):

public class NativeMethodExample {
    // Native методы (реализованы в C/C++)
    public native void systemExit(int code);
    public native void nativeMethod();
    
    // JVM может вызывать эти методы через JNI
}

Жизненный цикл объектов в памяти

Создание объекта

public class ObjectLifecycle {
    public static void main(String[] args) {
        // 1. JVM выделяет память в heap
        // 2. Вызывается конструктор
        // 3. Ссылка на объект в stack
        Person person = new Person("John", 30);
        
        // 4. Объект живет в памяти
        System.out.println(person.name);
        
    } // 5. Выходим из scope
      // 6. Ссылка удаляется из stack
      // 7. Garbage Collector позже удаляет объект из heap
}

class Person {
    String name;
    int age;
    
    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

Garbage Collection (автоматическое управление памятью)

Как JVM автоматически удаляет неиспользуемые объекты:

public class GarbageCollectionExample {
    public static void main(String[] args) {
        Person person1 = new Person("John");
        Person person2 = new Person("Jane");
        
        person1 = person2;  // старый person1 больше не нужен
        // Garbage Collector позже удалит неиспользуемый объект
        
        person2 = null;     // явно указываем, что объект не нужен
        // Garbage Collector удалит оба объекта
    }
}

Главное преимущество JVM — программист не должен вручную управлять памятью (в отличие от C/C++).

Практический пример: анализ памяти

public class MemoryAnalysis {
    static String globalString = "Global"; // Method Area
    
    public static void main(String[] args) {
        int localInt = 42;                 // stack
        String localString = "Local";      // ссылка в stack, String в heap
        int[] array = {1, 2, 3};          // ссылка в stack, массив в heap
        
        demonstrateMemory();               // новый stack frame
    }
    
    static void demonstrateMemory() {
        List<String> list = new ArrayList<>(); // stack frame для метода
        list.add("Item");                      // объект в heap
    }
}

Визуализация памяти:

Stack:
  localInt = 42
  localString -> (ссылка)
  array -> (ссылка)
  list -> (ссылка)

Heap:
  "Local" (String object)
  [1, 2, 3] (int array)
  ArrayList object

Method Area:
  globalString = "Global"
  MemoryAnalysis class info

Важные параметры JVM для памяти

# Максимальный размер heap
-Xmx2g

# Начальный размер heap
-Xms1g

# Размер stack для каждого потока
-Xss1m

# Размер Metaspace (Method Area в Java 8+)
-XX:MetaspaceSize=128M -XX:MaxMetaspaceSize=256M

Заключение

JVM хранит:

• Heap: объекты и массивы
• Stack: примитивы и ссылки на объекты
• Method Area/Metaspace: информацию о классах и методах
• PC Register: адреса инструкций
• Native Method Stack: информацию о native методах

Понимание этой архитектуры помогает:

• Писать эффективный код
• Отлаживать проблемы с памятью
• Оптимизировать приложения
• Избегать утечек памяти