Где хранится последовательность вызовов?

# Где хранится последовательность вызовов в Java

Ответ: CALL STACK (стек вызовов)

1. Стек вызовов (Call Stack)

Что это?

Call Stack — это специальная область памяти JVM, которая отслеживает последовательность вызовов методов. Каждый вызов метода создаёт новый frame (кадр) на стеке.

public class CallStackExample {
    public static void main(String[] args) {
        methodA();  // main → A
    }
    
    static void methodA() {
        methodB();  // A → B
    }
    
    static void methodB() {
        methodC();  // B → C
    }
    
    static void methodC() {
        System.out.println("C");
    }
}

// Стек вызовов в моменте выполнения methodC:
// ┌─────────┐
// │ methodC │
// ├─────────┤
// │ methodB │
// ├─────────┤
// │ methodA │
// ├─────────┤
// │  main   │
// └─────────┘

2. Структура одного frame (кадра стека)

Каждый frame содержит:

public class FrameStructure {
    static void example(int x, String name) {
        int localVar = 42;
        // Frame для example:
        // ┌─────────────────────────┐
        // │ Method: example         │
        // │ Parameters:             │
        // │   - x = 10              │
        // │   - name = "test"       │
        // │ Local Variables:        │
        // │   - localVar = 42       │
        // │ Operand Stack:          │
        // │   (промежуточные значен)│
        // └─────────────────────────┘
    }
}

Компоненты frame:

1. Method info — какой метод выполняется
2. Parameters — параметры метода (в Local Variable Array)
3. Local Variables — локальные переменные
4. Operand Stack — для промежуточных вычислений
5. Bytecode index — какая инструкция выполняется

3. Stack Trace (трассировка стека)

Просмотр стека

public class StackTraceExample {
    static void levelC() {
        throw new RuntimeException("Error in C");
    }
    
    static void levelB() {
        levelC();
    }
    
    static void levelA() {
        levelB();
    }
    
    public static void main(String[] args) {
        levelA();
    }
}

// Stack Trace при ошибке:
// Exception in thread "main" java.lang.RuntimeException: Error in C
//   at StackTraceExample.levelC(StackTraceExample.java:3)
//   at StackTraceExample.levelB(StackTraceExample.java:7)
//   at StackTraceExample.levelA(StackTraceExample.java:11)
//   at StackTraceExample.main(StackTraceExample.java:15)

Получить стек программно

public class GetStackTrace {
    public static void printStack() {
        // Способ 1: Exception
        new Exception().printStackTrace();
        
        // Способ 2: StackTraceElement
        StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace();
        for (StackTraceElement element : stackTrace) {
            System.out.println(element);
        }
        
        // Способ 3: Java 19+ (Virtual Threads)
        StackWalker walker = StackWalker.getInstance();
        walker.forEach(System.out::println);
    }
}

4. Правила работы со стеком

LIFO (Last In, First Out)

public class StackLIFO {
    public static void main(String[] args) {
        methodA();  // 1. Добавить A на стек
    }              // 5. Удалить A из стека
    
    static void methodA() {
        methodB();  // 2. Добавить B на стек
    }              // 4. Удалить B из стека
    
    static void methodB() {
        System.out.println("B");  // 3. Выполнить B
    }
}

// Порядок: main → A → B → (выполнить) → удалить B → удалить A → main

5. Размер стека и StackOverflowError

Проблема: бесконечная рекурсия

// ❌ ПЛОХО: бесконечный рекурсией
public class InfiniteRecursion {
    static void recursiveMethod() {
        recursiveMethod();  // Frame за frame добавляется на стек
        // Стек переполнится!
    }
}

// Результат:
// Exception in thread "main" java.lang.StackOverflowError
// at InfiniteRecursion.recursiveMethod(InfiniteRecursion.java:3)
// at InfiniteRecursion.recursiveMethod(InfiniteRecursion.java:3)
// at InfiniteRecursion.recursiveMethod(InfiniteRecursion.java:3)
// ... (тысячи раз)

Размер стека

# Настройка размера стека на JVM
java -Xss1m MyApplication   # 1 МБ на поток
java -Xss2m MyApplication   # 2 МБ на поток (по умолчанию обычно)

# Проверить текущий размер
java -XX:+PrintFlagsFinal -version | grep ThreadStackSize

6. Разница между Stack и Heap

public class StackVsHeap {
    public static void main(String[] args) {
        int age = 25;              // Stack: примитив
        String name = "John";      // Stack: ссылка, Heap: объект String
        User user = new User();    // Stack: ссылка, Heap: объект User
        
        // Stack содержит:
        // age = 25
        // name → (адрес объекта в Heap)
        // user → (адрес объекта в Heap)
    }
}

7. StackWalker API (Java 9+)

Современный способ работы со стеком

public class StackWalkerExample {
    public static void main(String[] args) {
        methodA();
    }
    
    static void methodA() {
        methodB();
    }
    
    static void methodB() {
        // Получить информацию о стеке
        StackWalker walker = StackWalker.getInstance(
            StackWalker.Option.RETAIN_CLASS_REFERENCE
        );
        
        walker.forEach(frame -> {
            System.out.println("Method: " + frame.getMethodName());
            System.out.println("File: " + frame.getFileName());
            System.out.println("Line: " + frame.getLineNumber());
            System.out.println("---");
        });
        
        // Или собрать в List
        List<StackWalker.StackFrame> frames = walker.walk(stream -> 
            stream.limit(5).collect(toList())
        );
    }
}

8. Практические примеры

Отслеживание вызовов

public class CallTracker {
    public static String getCurrentMethod() {
        StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace();
        // stackTrace[0] = getStackTrace()
        // stackTrace[1] = getCurrentMethod()
        // stackTrace[2] = наш вызыватель
        return stackTrace[2].getMethodName();
    }
    
    public static void main(String[] args) {
        System.out.println("Calling method: " + getCurrentMethod());
        // Output: Calling method: main
    }
}

Логирование с именем метода

public class Logger {
    public static void log(String message) {
        StackTraceElement element = Thread.currentThread().getStackTrace()[2];
        String caller = element.getClassName() + "." + element.getMethodName();
        System.out.println("[" + caller + "] " + message);
    }
    
    public static void main(String[] args) {
        log("Application started");
        // Output: [Main.main] Application started
    }
}

Profiling

public class MethodTimer {
    private static Map<String, Long> callCounts = new ConcurrentHashMap<>();
    
    public static void enter() {
        String method = Thread.currentThread().getStackTrace()[2].getMethodName();
        callCounts.compute(method, (k, v) -> (v == null ? 1 : v + 1));
    }
    
    public static void printStats() {
        callCounts.forEach((method, count) -> 
            System.out.println(method + " called " + count + " times")
        );
    }
}

9. Stack Frame в разных контекстах

Вложенные блоки

public class ScopeExample {
    static int globalVar = 1;
    
    static void method() {
        int methodVar = 2;           // Frame for method
        
        if (true) {
            int blockVar = 3;        // Тот же frame, новая переменная
            System.out.println(blockVar);
        }
        // blockVar недоступна
        
        {
            int anotherBlock = 4;    // Тот же frame
        }
    }
}

10. Memory layout

ЈVM Memory:
┌──────────────────────────────┐
│  Heap (разделяется потоками) │
│  • Объекты                   │
│  • Arrays                    │
│  • Strings (в String Pool)   │
└──────────────────────────────┘
          ↓
┌──────────────────────────────┐
│ Stack (один на каждый поток) │
│ • Локальные переменные       │
│ • Ссылки на объекты          │
│ • Frame методов              │
└──────────────────────────────┘

Заключение

Call Stack хранит последовательность вызовов методов:

1. ✅ Каждый вызов → новый frame на стеке
2. ✅ LIFO принцип: последний вызванный удаляется первым
3. ✅ Видно в stack trace при исключениях
4. ✅ Один стек на поток
5. ✅ Размер ограничен (-Xss параметр)
6. ✅ Программно доступен через StackTraceElement и StackWalker API