Как очищается Stack в JVM

Как очищается Stack в JVM

Это глубокий вопрос о устройстве памяти и управлении жизненным циклом объектов в Java. Рассмотрю детально, как работает очистка стека (stack) и что отличает его от heap.

1. Архитектура памяти JVM: Stack vs Heap

PAMYAT' JVM:
┌─────────────────────────────────────────┐
│         HEAP (KUCHA)                    │
│  - Dlya objektov                        │
│  - GC upravlyaet                        │
│  - Dolgozhivushchie dannyye             │
│                                         │
│  +─────────────────────────────────+    │
│  | User object                     |    │
│  +─────────────────────────────────+    │
│  | ArrayList<String>               |    │
│  +─────────────────────────────────+    │
│                                         │
└─────────────────────────────────────────┘
        ↑
        │
    Reference
        │
┌─────────────────────────────────────────┐
│         STACK (PER-THREAD)              │
│  - Dlya primityvov i ssylok             │
│  - Avtomaticheski ochisthaetsya         │
│  - LIFO (Last In First Out)             │
│                                         │
│ main():                                 │
│ ┌─────────────────────────────────┐    │
│ │ user: @12345 (ssylka)           │    │
│ │ age: 25 (primityv)              │    │
│ │ name: @67890 (ssylka)           │    │
│ └─────────────────────────────────┘    │
│                                         │
│ processUser():                          │
│ ┌─────────────────────────────────┐    │
│ │ localUser: @12345               │    │
│ │ count: 5                        │    │
│ └─────────────────────────────────┘    │
│                                         │
└─────────────────────────────────────────┘

2. Автоматическая очистка Stack: Stack Frame удаляется при выходе из метода

public class StackDemo {
    public static void main(String[] args) {
        System.out.println("--- Before method call");
        demonstrateStack();
        System.out.println("--- After method call, local variables cleaned up");
    }
    
    private static void demonstrateStack() {
        // STACK FRAME для этого метода создан
        int x = 10;                    // Stack: x = 10
        String name = "John";          // Stack: name = @address (Heap: "John")
        List<Integer> numbers = new ArrayList<>();  // Stack: numbers = @ref (Heap: ArrayList)
        
        numbers.add(x);                // Добавляем в объект на Heap
        
        System.out.println("Inside method, stack contains: x, name, numbers");
        // Здесь все локальные переменные живы
    }
    // STACK FRAME УДАЛЕН! Все локальные переменные очищены
    // Но объекты на Heap (String "John", ArrayList) могут остаться если на них есть ссылки
}

3. Процесс очистки Stack: LIFO (Last In First Out)

public class CallStackDemo {
    public static void main(String[] args) {
        System.out.println("Stack state: [main]");
        methodA();
        System.out.println("Stack state: [main]");
    }
    
    static void methodA() {
        System.out.println("Stack state: [main → methodA]");
        methodB();
        System.out.println("Stack state: [main → methodA]  (после выхода из B)");
    }
    
    static void methodB() {
        System.out.println("Stack state: [main → methodA → methodB]");
        methodC();
        System.out.println("Stack state: [main → methodA → methodB]  (после выхода из C)");
    }
    
    static void methodC() {
        System.out.println("Stack state: [main → methodA → methodB → methodC]");
        int localVar = 100;
        System.out.println("Stack state: [main → methodA → methodB → methodC] + localVar");
    }
    // Выход из methodC: удален весь его Stack Frame
}

// Вывод:
// Stack state: [main]
// Stack state: [main → methodA]
// Stack state: [main → methodA → methodB]
// Stack state: [main → methodA → methodB → methodC]
// Stack state: [main → methodA → methodB → methodC] + localVar
// Stack state: [main → methodA → methodB]  (после выхода из C)
// Stack state: [main → methodA]  (после выхода из B)
// Stack state: [main]

4. StackOverflowError: переполнение Stack

Stack имеет ОГРАНИЧЕННЫЙ размер (обычно 1MB на Linux, 512KB на Windows):

public class StackOverflowDemo {
    private static int counter = 0;
    
    public static void main(String[] args) {
        try {
            infiniteRecursion();
        } catch (StackOverflowError e) {
            System.out.println("StackOverflowError at recursion depth: " + counter);
            e.printStackTrace();
        }
    }
    
    static void infiniteRecursion() {
        counter++;
        if (counter % 1000 == 0) {
            System.out.println("Recursion depth: " + counter);
        }
        infiniteRecursion(); // Каждый вызов создает новый Stack Frame
    }
}

// Вывод:
// Recursion depth: 1000
// Recursion depth: 2000
// Recursion depth: 3000
// ...
// Recursion depth: 13000
// StackOverflowError at recursion depth: 13579

5. Stack Pointer и Program Counter

public class StackPointerDemo {
    public static void main(String[] args) {
        // Stack Pointer указывает на вершину Stack
        // Program Counter указывает на текущую инструкцию
        
        method1();
    }
    
    static void method1() {
        // PC: адрес первой инструкции в method1
        // SP: новый Stack Frame создан
        int local1 = 10;
        method2();
        // SP возвращается на место после вызова method2
    }
    
    static void method2() {
        // SP: новый Stack Frame создан выше previous
        int local2 = 20;
        // Здесь максимум Stack глубины
    }
    // SP возвращается, все локальные переменные method2 удаляются
}

6. Параметры JVM для управления Stack размером

# Размер Stack для основного потока (по умолчанию 1MB на Linux)
java -Xss1m MyApplication

# Для больших Stack'ов (например, для глубокой рекурсии)
java -Xss10m MyApplication

# Маленький Stack (экономия памяти)
java -Xss256k MyApplication

7. Per-Thread Stack: каждый поток имеет свой Stack

public class PerThreadStackDemo {
    public static void main(String[] args) {
        // Основной поток имеет свой Stack
        Thread thread1 = new Thread(() -> {
            // thread1 имеет свой Stack (1MB по умолчанию)
            int x = 10;
            String name = "Thread 1";
            someMethod();
        });
        
        Thread thread2 = new Thread(() -> {
            // thread2 имеет свой отдельный Stack (ещё 1MB)
            int x = 20;
            String name = "Thread 2";
            someMethod();
        });
        
        thread1.start();
        thread2.start();
    }
    
    static void someMethod() {
        // Каждый поток: выполняет в своем Stack Frame
    }
}

// Общее использование памяти:
// - Основной поток Stack: 1MB
// - thread1 Stack: 1MB
// - thread2 Stack: 1MB
// ИТОГО: 3MB только на Stack'и

8. Stack и локальные переменные: время жизни

public class LocalVariableLifetime {
    public String processUser(Long userId) {
        // userId на Stack (примитив/ссылка)
        // Требует 8 байт (64-bit reference)
        
        User user = findUserFromDatabase(userId);
        // user на Stack, User объект на Heap
        // Stack: 8 байт для ссылки
        // Heap: 96+ байт для User объекта
        
        String fullName = user.getFirstName() + " " + user.getLastName();
        // fullName на Stack
        // String объекты на Heap
        
        List<Order> orders = user.getOrders();
        // orders на Stack (ссылка на ArrayList)
        // ArrayList на Heap
        // Элементы ArrayList на Heap
        
        return fullName;
    }
    // Stack Frame удален, все локальные переменные очищены
    // Heap объекты (User, List, String) могут остаться если на них есть ссылки
    
    private User findUserFromDatabase(Long userId) {
        // userId на Stack внутри этого метода
        User foundUser = new User(userId);
        // foundUser на Stack (ссылка)
        // User объект на Heap
        
        return foundUser;
    }
    // Stack Frame удален, но User объект остаётся (есть ссылка из processUser)
}

9. Exception Stack Trace: что это?

public class ExceptionStackTraceDemo {
    public static void main(String[] args) {
        try {
            methodA();
        } catch (Exception e) {
            System.out.println("Stack Trace (состояние Stack в момент ошибки):");
            e.printStackTrace();
            // Выводит всю цепочку вызовов методов в том момент
        }
    }
    
    static void methodA() {
        methodB();
    }
    
    static void methodB() {
        methodC();
    }
    
    static void methodC() {
        throw new RuntimeException("Error in C");
    }
}

// Stack Trace (состояние Stack в момент ошибки):
// java.lang.RuntimeException: Error in C
//     at ExceptionStackTraceDemo.methodC(ExceptionStackTraceDemo.java:20)
//     at ExceptionStackTraceDemo.methodB(ExceptionStackTraceDemo.java:16)
//     at ExceptionStackTraceDemo.methodA(ExceptionStackTraceDemo.java:12)
//     at ExceptionStackTraceDemo.main(ExceptionStackTraceDemo.java:8)

10. Stack vs Heap: различия в управлении памятью

STACK:
✓ Автоматическая очистка (выход из метода)
✓ Очень быстрое выделение памяти
✓ Очень быстрое освобождение памяти
✓ LIFO порядок (простая структура)
✗ Ограниченный размер (~1MB)
✗ Только локальные переменные и ссылки
✗ StackOverflowError при переполнении

HEAP:
✓ Большой размер (зависит от -Xmx)
✓ Хранит объекты (String, ArrayList, User, etc)
✗ Требует Garbage Collection
✗ Более медленное выделение/освобождение
✗ OutOfMemoryError возможно

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

// ПЛОХО: глубокая рекурсия может переполнить Stack
public int fibonacci(int n) {
    if (n <= 1) return n;
    return fibonacci(n - 1) + fibonacci(n - 2);
}
// fibonacci(1000) → StackOverflowError

// ХОРОШО: итеративный подход
public int fibonacciIterative(int n) {
    if (n <= 1) return n;
    int prev = 0, curr = 1;
    for (int i = 2; i <= n; i++) {
        int next = prev + curr;
        prev = curr;
        curr = next;
    }
    return curr;
}
// fibonacci(1000) → работает без проблем

// ХОРОШО: tail recursion с trampolining
public Integer fibonacciTrampoline(int n) {
    return tailRecursive(n, 0, 1);
}

private Integer tailRecursive(int n, int acc1, int acc2) {
    if (n == 0) return acc1;
    if (n == 1) return acc2;
    return tailRecursive(n - 1, acc2, acc1 + acc2);
}

12. Инструменты для анализа Stack

// Программно получить Stack Trace
public void dumpStack() {
    StackTraceElement[] stack = Thread.currentThread().getStackTrace();
    for (StackTraceElement element : stack) {
        System.out.println(element.getClassName() + "." + 
                          element.getMethodName() + ":" + 
                          element.getLineNumber());
    }
}

// Анализ Stack глубины
public int getCurrentStackDepth() {
    return Thread.currentThread().getStackTrace().length - 1;
}

Ключевые выводы

1. Stack автоматически очищается — при выходе из метода
2. Stack LIFO структура — последний вошедший первый выйдет
3. Размер ограничен — обычно 1MB, может привести к StackOverflowError
4. Per-thread Stack — каждый поток имеет свой Stack
5. Только локальные переменные — примитивы и ссылки на объекты
6. Очень быстро — выделение и освобождение памяти тривиально
7. Избегайте глубокой рекурсии — можно переполнить Stack

Понимание Stack важно для:

• Отладки (Stack Trace)
• Оптимизации памяти
• Избежания StackOverflowError
• Работы многопоточных приложений