Структура памяти в Java: стек и куча

Стек (stack) и куча (heap) — две основные области памяти, которыми управляет JVM во время работы программы. В куче живут объекты и массивы, в стеке — кадры вызовов методов с локальными переменными и ссылками на эти объекты. Память в куче освобождает сборщик мусора, память в стеке — сама JVM, как только метод завершился.

Структура памяти в Java устроена сложнее, чем «стек и куча», но на старте достаточно разобраться именно с этими двумя областями: через них объясняется почти всё поведение переменных, объектов и сборщика мусора.

1. Куча (heap)

Java Heap (куча) — область памяти, которую JVM выделяет при старте приложения и использует для размещения всех объектов и массивов. Каждый раз, когда выполняется new, память под новый объект берётся именно из кучи.

Именно в куче работает сборщик мусора (garbage collector): он находит объекты, до которых больше нельзя добраться ни по одной цепочке ссылок, и освобождает занятую ими память. Разработчику не нужно удалять объекты вручную.

Куча одна на всю JVM и общая для всех потоков приложения. Поэтому объект, созданный в одном потоке, может быть прочитан и изменён из другого — и поэтому же общие объекты приходится защищать синхронизацией.

Важное уточнение: объект в куче не «виден отовсюду» сам по себе. Обратиться к нему можно только через ссылку — если ссылку никуда не передали и она пропала, объект становится недостижимым и рано или поздно будет собран сборщиком мусора.

2. Стек (stack)

Стековая память в Java работает по принципу LIFO (last in — first out, «последним зашёл — первым вышел»). При каждом вызове метода на вершине стека создаётся новый кадр стека (stack frame), в котором хранятся:

• локальные переменные метода примитивных типов (их значения),
• ссылки на объекты, лежащие в куче,
• параметры метода и служебная информация для возврата.

Как только метод завершает работу, его кадр снимается со стека, и память освобождается мгновенно — сборщик мусора здесь не участвует.

У каждого потока свой собственный стек. Локальные переменные потока по определению недоступны другим потокам, поэтому они всегда потокобезопасны. Размер стека намного меньше размера кучи: обычно это сотни килобайт — единицы мегабайт на поток.

Ключевое правило: объект всегда создаётся в куче, а в стеке лежит только ссылка на него. Значение ссылочной переменной — это не сам объект, а адрес объекта в куче.

3. Пример: что попадает в стек, а что в кучу

Разберём разницу между примитивной и ссылочной переменной. При объявлении int a = 10 само значение 10 хранится в стеке. При создании Test a = new Test() объект размещается в куче, а переменная a находится в стеке и содержит ссылку на этот объект:

Теперь то же самое в коде:

public class MemoryDemo {

    static class Point {
        int x;   // поле объекта - хранится в куче вместе с объектом
        int y;
    }

    public static void main(String[] args) {
        int a = 10;              // значение 10 лежит в кадре стека метода main
        Point p = new Point();   // объект Point - в куче, ссылка p - в стеке
        p.x = 5;                 // изменяем поле объекта в куче

        modify(p);               // передаём копию ссылки

        System.out.println(a);   // 10
        System.out.println(p.x); // 42 - метод изменил тот же объект в куче
    }

    static void modify(Point point) {  // новый кадр стека
        point.x = 42;                  // point и p указывают на один объект
    }                                  // кадр снимается со стека
}

Пример показывает сразу три вещи: значение примитива копируется, ссылка тоже копируется (Java всегда передаёт аргументы по значению), но копия ссылки указывает на тот же самый объект в куче — поэтому изменения полей видны в вызывающем методе.

4. Стек и куча: сравнение

5. Metaspace и другие области памяти JVM

Стек и куча — не вся картина. Современная JVM (HotSpot) использует ещё несколько областей:

• Metaspace — метаданные загруженных классов и методов. Начиная с Java 8 они хранятся в нативной памяти операционной системы, а не в куче.
• Пул строк (String pool) — с Java 7 находится в куче, поэтому строковые литералы тоже подлежат сборке мусора.
• Code Cache — машинный код, сгенерированный JIT-компилятором.
• Регистры PC и стек нативных методов — служебные области, свои у каждого потока.

6. StackOverflowError и OutOfMemoryError

Две классические ошибки памяти напрямую связаны с двумя областями.

StackOverflowError возникает, когда закончилось место в стеке потока. Самая частая причина — рекурсия без условия выхода: каждый вызов добавляет кадр, и стек переполняется.

public class StackOverflowDemo {
    static int depth = 0;

    static void recurse() {
        depth++;
        recurse();   // нет условия выхода
    }

    public static void main(String[] args) {
        try {
            recurse();
        } catch (StackOverflowError e) {
            System.out.println("Глубина рекурсии: " + depth);
        }
    }
}

OutOfMemoryError: Java heap space возникает, когда в куче не осталось места для нового объекта, а сборщик мусора не может ничего освободить — например, из-за коллекции, которая бесконечно растёт и удерживает ссылки на объекты (утечка памяти).

Размеры областей задаются при запуске JVM:

java -Xms256m -Xmx1g -Xss512k -XX:MaxMetaspaceSize=256m MyApp

Здесь -Xms — начальный размер кучи, -Xmx — максимальный, -Xss — размер стека одного потока, -XX:MaxMetaspaceSize — предел Metaspace.