Как переходят данные между Stack и Heap

Переход данных между Stack и Heap в Java

Понимание того, как данные движутся между Stack и Heap, критично для оптимизации памяти и понимания производительности Java приложений.

Stack vs Heap: различия

Stack (стек)

• Хранит примитивные типы и ссылки на объекты
• LIFO структура (Last In First Out)
• Быстро выделяется и освобождается память
• Автоматическое управление (очищается при выходе из метода)
• Ограниченный размер (может быть StackOverflowError)
• Потокобезопасен (каждый поток имеет свой stack)
• Работает с локальными переменными

Heap (куча)

• Хранит все объекты (экземпляры классов)
• Управляется сборщиком мусора (Garbage Collector)
• Медленнее, чем stack
• Разделен между всеми потоками
• Может быть OutOfMemoryError
• Требует явного удаления или GC

Примеры размещения в памяти

Пример 1: Примитивные типы и ссылки

public class MemoryExample {
    public static void main(String[] args) {
        // Stack:
        int age = 25;              // Примитив int
        double salary = 5000.50;   // Примитив double
        String name = "John";      // Ссылка на String объект в Heap
        
        // В Stack находятся: age=25, salary=5000.50, и ссылка name="0x1a2b3c"
        // В Heap находятся: объект String "John" по адресу 0x1a2b3c
    }
}

Визуально:

Stack (главный поток):           Heap:
┌──────────────────┐           ┌─────────────────┐
│ age = 25         │           │ String "John"   │
├──────────────────┤           │ адрес 0x1a2b3c  │
│ salary = 5000.50 │           └─────────────────┘
├──────────────────┤                    ↑
│ name = 0x1a2b3c  ├────────────────────┘
└──────────────────┘

Пример 2: Объекты

public class Person {
    private String name;
    private int age;
    private double salary;
}

public class Main {
    public static void main(String[] args) {
        Person person = new Person();  // На Stack: ссылка person
        person.name = "Alice";         // На Heap: объект Person
        person.age = 30;               // На Heap
        person.salary = 6000;          // На Heap
    }
}

Визуально:

Stack:                      Heap:
┌──────────────────┐       ┌─────────────────────┐
│ person = 0x5a7b9│──────→│ Person объект       │
└──────────────────┘       │ {                   │
                           │   name: "Alice"     │
                           │   age: 30           │
                           │   salary: 6000      │
                           │ }                   │
                           └─────────────────────┘

Переход данных между Stack и Heap

Переход 1: Передача объекта в метод

public class PassingByReference {
    static class Account {
        int balance = 1000;
    }
    
    static void withdraw(Account acc, int amount) {
        // На Stack метода withdraw:
        // - локальная переменная acc содержит ССЫЛКУ на объект из Heap
        // - локальная переменная amount = 500
        
        acc.balance -= amount;  // Изменяем объект в Heap через ссылку
    }
    
    public static void main(String[] args) {
        Account myAccount = new Account();  // Объект на Heap
        
        // На Stack main:
        // - myAccount содержит ССЫЛКУ на объект Account в Heap
        
        withdraw(myAccount, 500);
        
        // myAccount.balance теперь = 500 (изменения в Heap видны!)
    }
}

Переход 2: Возврат объекта из метода

public class ReturningObject {
    static class User {
        String username;
    }
    
    static User createUser(String username) {
        // На Stack метода:
        User user = new User();  // Объект создан на Heap
        user.username = username;
        
        return user;  // Возвращаем ССЫЛКУ на объект
    }
    
    public static void main(String[] args) {
        User newUser = createUser("john_doe");
        
        // На Stack main:
        // - newUser содержит ССЫЛКУ на объект User из Heap
        // - Объект в Heap все еще существует, пока на него есть ссылка
        
        System.out.println(newUser.username);  // "john_doe"
    }
}

Жизненный цикл объекта

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

public class ObjectLifecycle {
    public static void main(String[] args) {
        // 1. Выделение памяти на Heap
        // 2. Инициализация полей значениями по умолчанию
        // 3. Вызов конструктора
        // 4. Ссылка на Stack указывает на объект
        
        StringBuilder sb = new StringBuilder();
        
        // На Stack: sb = 0x123abc
        // На Heap: StringBuilder объект по адресу 0x123abc
    }
}

Удаление объекта (GC)

public class GarbageCollection {
    public static void main(String[] args) {
        String str = "Hello";  // Объект на Heap, ссылка на Stack
        
        str = "World";  // Новый объект на Heap
        // Старый объект "Hello" теперь не имеет ссылок
        // GC может очистить его память
        
        str = null;  // Явно убираем ссылку
        // Объект "World" может быть удален GC
    }
}

Скопирование между Stack и Heap

Копирование примитивов (Pass by value)

public class PrimitivesCopy {
    static void modify(int x) {
        x = 100;  // Изменяем копию в Stack метода modify
    }
    
    public static void main(String[] args) {
        int original = 50;
        modify(original);
        
        System.out.println(original);  // 50 (не изменилось)
        // Причина: примитивы копируются по значению
    }
}

Копирование объектов (Pass by reference)

public class ObjectsCopy {
    static class Data {
        int value = 50;
    }
    
    static void modify(Data data) {
        data.value = 100;  // Изменяем объект в Heap
    }
    
    public static void main(String[] args) {
        Data original = new Data();
        modify(original);
        
        System.out.println(original.value);  // 100 (изменилось!)
        // Причина: ссылка скопирована, но оба указывают на Heap
    }
}

Escape Analysis

Sovreм Java компиляторы используют Escape Analysis для оптимизации:

public class EscapeAnalysis {
    static class Point {
        int x, y;
    }
    
    public int calculateDistance() {
        // Компилятор видит, что point не "выходит" из метода
        // Может оптимизировать и разместить на Stack вместо Heap
        Point point = new Point();
        point.x = 10;
        point.y = 20;
        return point.x + point.y;
    }
    
    public Point getPoint() {
        // point "выходит" из метода (возвращается)
        // Должен быть на Heap
        Point point = new Point();
        return point;
    }
}

String и Pool of Strings

public class StringPool {
    public static void main(String[] args) {
        // String literal сохраняются в String Pool на Heap
        String s1 = "Hello";      // На Stack: s1 -> Heap String Pool
        String s2 = "Hello";      // На Stack: s2 -> тот же объект в Heap
        String s3 = new String("Hello");  // На Heap (обычная область, не pool)
        
        System.out.println(s1 == s2);     // true (одна ссылка)
        System.out.println(s1 == s3);     // false (разные объекты)
        System.out.println(s1.equals(s3)); // true (одинаковое содержимое)
    }
}

Влияние на производительность

Проблема 1: Частое создание объектов

public class PerformanceProblem {
    // Плохо: создаёт много объектов в Heap
    public String concatenateStrings(String[] strings) {
        String result = "";
        for (String s : strings) {
            result = result + s;  // Каждая итерация создает новый String
        }
        return result;
    }
    
    // Хорошо: переиспользует буфер
    public String concatenateStringsOptimized(String[] strings) {
        StringBuilder sb = new StringBuilder();
        for (String s : strings) {
            sb.append(s);  // Одно место в памяти
        }
        return sb.toString();
    }
}

Проблема 2: Утечки памяти

public class MemoryLeak {
    static List<String> cache = new ArrayList<>();
    
    public void addToCache(String item) {
        cache.add(item);  // Объект в Heap, ссылка в static cache
    }
    
    // Проблема: cache никогда не очищается
    // Объекты в Heap не удаляются, хотя могут быть ненужны
}

Переход данных в многопоточной среде

public class MultiThreading {
    public static void main(String[] args) {
        // Каждый поток имеет свой Stack
        // Но все потоки делят один Heap
        
        int localVar = 100;  // Stack главного потока
        MyObject obj = new MyObject();  // Heap (разделяется)
        
        new Thread(() -> {
            // Stack этого потока
            int threadLocalVar = 200;
            // Может читать/изменять obj из Heap
            obj.setValue(300);
        }).start();
    }
}

Резюме

Stack:

• Примитивные типы и ссылки
• Локальные переменные методов
• Быстро выделяется/освобождается
• Потокобезопасен

Heap:

• Все объекты
• Управляется GC
• Разделяется между потоками
• Требует внимания к утечкам

Переход данных:

• Примитивы копируются по значению
• Объекты передаются по ссылке
• Ссылки хранятся на Stack
• Сами объекты на Heap
• GC удаляет объекты без ссылок