Долго ли существуют объекты в памяти JVM

# Жизненный цикл объектов в памяти JVM

Ответ: зависит от многих факторов

Объекты в памяти JVM существуют от миллисекунд до всей жизни приложения. Продолжительность зависит от ссылок на объект и сборки мусора.

Основной принцип: Garbage Collection

Объект удаляется из памяти, когда на него нет ни одной ссылки (нет достижимости из корневых объектов).

{
    String temp = new String("Hello");  // Объект создан
    System.out.println(temp);           // Объект используется
}   // Конец блока - ссылка temp удалена
    // Объект может быть удален сборщиком мусора

Жизненный цикл объектов в памяти

Фаза 1: Создание (Creation)

User user = new User("Alice", 30);
// Объект создан в Heap памяти
// Ссылка user хранится в Stack

Время: наносекунды

Фаза 2: Использование (Usage)

user.setName("Alice");
user.getAge();
// Объект существует столько, сколько на него есть ссылка

Время: от миллисекунд до годов

Фаза 3: Недостижимость (Unreachability)

user = null;  // Ссылка удалена
// или
user = new User("Bob", 25);  // Старая ссылка заменена
// Объект становится недостижимым

Время: в момент удаления ссылки

Фаза 4: Удаление (Garbage Collection)

// JVM время от времени запускает сборщик мусора
// Он находит все недостижимые объекты и удаляет их
// Это может произойти сразу или через секунды

Время: непредсказуемо (от миллисекунд до минут)

Примеры разной продолжительности жизни

1. Очень короткоживущий объект (миллисекунды)

public void processRequest(HttpRequest request) {
    String json = request.getBody();           // Объект #1
    JsonParser parser = new JsonParser();      // Объект #2
    JsonObject obj = parser.parse(json);       // Объект #3
    
    String result = obj.toString();
    return result;
    // Все локальные объекты удалены из Stack
    // GC удалит их из Heap через миллисекунды
}

Жизненный цикл: < 1 мс

2. Кратковременный объект (секунды)

@Transactional
public void createUser(UserDTO dto) {
    User user = new User();              // Объект создан
    user.setName(dto.getName());
    userRepository.save(user);           // Сохранено в БД
}   // Ссылка удалена, GC удалит из памяти

// Объект существовал в памяти несколько миллисекунд

Жизненный цикл: мс - сотни мс

3. Долгоживущий объект (часы-дни)

@Service
public class UserCache {
    private final Map<Integer, User> cache = new ConcurrentHashMap<>();
    
    public void cacheUser(User user) {
        cache.put(user.getId(), user);
        // Объект остаётся в памяти пока в кеше
    }
    
    @Scheduled(fixedDelay = 86400000) // 24 часа
    public void clearCache() {
        cache.clear();
        // Только сейчас объекты могут быть удалены
    }
}

Жизненный цикл: часы

4. Постоянный объект (всё время работы приложения)

@Service
public class ApplicationConfig {
    private final DatabasePool dbPool;
    
    @Autowired
    public ApplicationConfig(DatabasePool dbPool) {
        this.dbPool = dbPool;  // Объект создан при старте приложения
    }
    // Существует столько же, сколько работает приложение
}

// Spring Singleton - хранится в ApplicationContext
// Удаляется только при shutdown приложения

Жизненный цикл: дни/недели/месяцы

Хранилище памяти в JVM

Stack (быстрое, но маленькое)

void example() {
    int x = 5;                    // В Stack (4 байта)
    String str = "Hello";         // Ссылка в Stack, объект в Heap
    User user = new User();       // Ссылка в Stack, объект в Heap
}
// При выходе из метода - всё удаляется из Stack
// Объекты в Heap остаются, пока есть ссылки

Время жизни на Stack: длительность метода

Heap (медленнее, но больше)

public class Application {
    private static List<User> users = new ArrayList<>();  // В Heap
    
    public static void main(String[] args) {
        User user = new User();                           // Ссылка в Stack
        users.add(user);                                   // Ссылка из List
        // user из Stack удалится при выходе из main
        // Но объект в Heap остаётся (есть ссылка из List)
    }
}

Время жизни в Heap: пока есть хотя бы одна ссылка

Сборка мусора (Garbage Collection)

Молодое поколение (Young Generation)

// Объекты в Young Gen удаляются часто (Minor GC)
// Каждые несколько миллисекунд
for (int i = 0; i < 1000000; i++) {
    String temp = new String("temp" + i);  // Создание
    // Сразу же удаление при выходе из итерации
    // Minor GC очистит все эти объекты
}

Жизненный цикл: миллисекунды

Старое поколение (Old Generation)

List<String> cache = new ArrayList<>();
while (true) {
    String data = getDataFromDatabase();
    cache.add(data);  // Добавляем в кеш
    // Объекты переживают несколько Minor GC
    // Перемещаются в Old Gen
    // Остаются там долго
}

Жизненный цикл: часы - дни

Permanent Generation / Metaspace (для классов и метаданных)

// Загруженные классы хранятся в Metaspace
// Удаляются только при выгрузке ClassLoader
// Практически не удаляются во время работы приложения

Жизненный цикл: всё время работы приложения

Как узнать, долго ли живёт объект

1. Через логирование

public class LifetimeTracker {
    public LifetimeTracker(String name) {
        System.out.println("Создан: " + name + " в " + System.currentTimeMillis());
    }
    
    @Override
    protected void finalize() throws Throwable {
        System.out.println("Удалён: " + " в " + System.currentTimeMillis());
        super.finalize();
    }
}

// Использование
LifetimeTracker tracker = new LifetimeTracker("Object1");
tracker = null;
System.gc();  // Принудительный вызов GC

2. Через JVisualVM или JProfiler

Эти инструменты показывают:

• Сколько объектов в памяти
• Как долго они живут
• Когда они удаляются

3. Через мониторинг GC

# Запуск JVM с логированием GC
java -Xmx512m -XX:+PrintGCDetails -XX:+PrintGCDateStamps Main

# Результат:
# 2024-03-22T10:30:00.123+0000: [GC (Allocation Failure) ...
# ...выполнена сборка мусора...

Оптимизация времени жизни объектов

1. Объекты-местные переменные (минимум памяти)

public String processData(String data) {
    String result = transformData(data);  // Локальная переменная
    return result;
}  // Удалится при выходе из метода

2. Object Pool (переиспользование)

public class StringPool {
    private static final Set<String> pool = new HashSet<>();
    
    public static String getString(String value) {
        if (!pool.contains(value)) {
            pool.add(value);
        }
        return pool.stream()
            .filter(s -> s.equals(value))
            .findFirst()
            .orElse(null);
    }
}

// Вместо:
String s1 = new String("hello");
String s2 = new String("hello");
// s1 и s2 - разные объекты

// Лучше:
String s1 = StringPool.getString("hello");
String s2 = StringPool.getString("hello");
// s1 и s2 - ОДИН объект (переиспользуется)

3. Слабые ссылки (Weak References)

// WeakReference - объект может быть удалён даже если есть ссылка
WeakReference<String> ref = new WeakReference<>(new String("temp"));
String value = ref.get();
if (value == null) {
    System.out.println("Объект уже удалён!");
}

4. Try-with-resources

// Ресурс автоматически закроется и удалится
try (BufferedReader reader = new BufferedReader(new FileReader("file.txt"))) {
    String line = reader.readLine();
}  // reader удалится здесь автоматически

Типичные времена жизни в enterprise приложении

Вывод

Объекты в JVM существуют:

• От миллисекунд (локальные переменные, временные объекты)
• До часов-дней (кешированные данные, сессии)
• До месяцев (статические переменные, кластеры)
• Всё время (Spring бины, Metaspace классы)

Продолжительность жизни зависит от:

1. ✓ Есть ли ссылки на объект
2. ✓ Откуда хранятся эти ссылки (Stack, Heap, static)
3. ✓ Как часто запускается Garbage Collection
4. ✓ Размер памяти и настройки JVM
5. ✓ Архитектура приложения