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

Что хранится в Stack

Stack (стек) — это область памяти, используемая для хранения локальных переменных, ссылок на объекты и информации о вызовах методов в Java. Это один из двух основных механизмов управления памятью в JVM, наряду с Heap.

Основные элементы Stack

1. Локальные переменные примитивных типов

public void example() {
    int x = 10;           // Сам int (значение 10) хранится в Stack
    double y = 3.14;      // Сама double (значение 3.14) хранится в Stack
    boolean flag = true;  // Сама boolean хранится в Stack
}

В Stack хранятся сами значения (10, 3.14, true), а не ссылки на них.

2. Ссылки на объекты (не сами объекты)

public void example() {
    String name = "John";  // Ссылка на String объект хранится в Stack
    // Сам объект String хранится в Heap
    
    Person person = new Person(); // Ссылка (адрес) хранится в Stack
    // Сам объект Person хранится в Heap
}

В Stack хранятся только ссылки (адреса памяти), указывающие на объекты в Heap.

3. Информация о вызовах методов (Stack Frame)

Для каждого вызова метода создаётся Stack Frame:

public void methodA() {
    int a = 5;
    methodB();
}

public void methodB() {
    String b = "hello";
    methodC();
}

public void methodC() {
    double c = 2.5;
}

Stack растёт сверху вниз:

┌─────────────────────────┐
│ methodC Frame           │
│ c = 2.5                 │
├─────────────────────────┤
│ methodB Frame           │
│ b = ссылка на "hello"   │
├─────────────────────────┤
│ methodA Frame           │
│ a = 5                   │
├─────────────────────────┤
│ main Frame              │
└─────────────────────────┘

Что НЕ хранится в Stack

// НЕ ХРАНИТСЯ в Stack (только в Heap):
String name = "John";        // Сам String объект
List<Integer> list = new ArrayList<>();  // Сам ArrayList объект
CustomClass obj = new CustomClass();     // Сам объект класса

Сами объекты — всегда в Heap, в Stack только ссылки на них.

Полный пример с визуализацией

public class StackExample {
    public static void main(String[] args) {
        int x = 10;                    // Stack: x = 10
        String str = "Hello";          // Stack: str -> [Heap: "Hello"]
        Person person = new Person();  // Stack: person -> [Heap: Person object]
    }
}

class Person {
    String name = "John";  // Heap: Person object содержит name = ссылку на "John"
    int age = 25;          // Heap: Person object содержит age = 25
}

Stack:

• x = 10
• str = адрес объекта String в Heap
• person = адрес объекта Person в Heap

Heap:

• String объект "Hello"
• Person объект с полями name и age

Размер и ограничения Stack

// Каждый поток получает собственный Stack
Thread thread1 = new Thread(() -> {
    int[] arr = new int[1000]; // Может привести к StackOverflowError
});

// StackOverflowError при глубокой рекурсии
public int recursion(int n) {
    return recursion(n + 1);  // Каждый вызов создаёт новый Stack Frame
}

Размер Stack можно настроить параметром JVM: -Xss1m (1 мегабайт).

Stack vs Heap

Порядок очистки Stack

public void example() {
    int x = 10;      // Добавляется в Stack
    String s = "hi"; // Ссылка добавляется в Stack
    // ... код ...
}                    // Все локальные переменные удаляются из Stack
// x и s удалены из Stack
// Ссылка s исчезла, но объект "hi" всё ещё в Heap (пока GC не удалит)

Stack работает по принципу LIFO (Last-In-First-Out): последние добавленные переменные удаляются первыми при выходе из метода.

Вывод: Stack хранит локальные переменные примитивных типов и ссылки на объекты, обеспечивая быстрый доступ и автоматическое управление памятью при выходе из методов.