Я пытаюсь понять, как понятия молодые, старые и постоянные поколения в терминологии кучи Java, а точнее, взаимодействия между тремя поколениями.
Мои вопросы:
Это похоже на общее недоразумение. В Oracle JVM постоянное поколение не является частью кучи. Это отдельное пространство для определений классов и связанных с ними данных. В Java 6 и ранее интернированные строки также были сохранены в постоянном поколении. В Java 7 интернированные строки хранятся в куче основного объекта.
Вот хороший пост в постоянном поколении.
Мне нравятся описания для каждого пространства в Oracle руководство по JConsole:
Для виртуальной машины Java HotSpot память бассейны для серийной сборки мусора следующие.
- Eden Space (куча): пул, из которого первоначально выделена память для большинства объектов.
- Survivor Space (куча): пул, содержащий выжившие объекты мусорная коллекция Идена пространство.
- Наложенное поколение (куча): пул, содержащий объекты, которые существовали в течение некоторого времени в оставшемся в живых пространстве.
- Постоянное поколение (не куча): пул, содержащий все отражающие данные самой виртуальной машины, таких как объекты класса и метода. С Java-виртуальные машины, использующие совместное использование данных классов, это поколение делится на только для чтения и чтения-записи.
- Кэш-код (не куча): виртуальная машина HotSpot Java также включает в себя кеш-код, содержащую память, которая используется для сбор и хранение родных код.
Java использует коллекцию мусора для генерации. Это означает, что если у вас есть объект foo (который является экземпляром какого-либо класса), чем больше событий сбора мусора он выживает (если есть еще ссылки на него), тем дальше он продвигается. Он начинается в молодое поколение (которое само по себе разделено на несколько пространств - Eden и Survivor) и в конечном итоге окажется в поколенном поколении, если оно выживет достаточно долго.
Куча делится на молодые и старые поколения следующим образом:
Молодое поколение. Это место, где жили в течение короткого периода времени и делились на два пространства:
Старое поколение. Этот пул в основном содержит измененные и виртуальные (зарезервированное) пространство и будет удерживать оставшиеся объекты после сбора мусора из Young Generation.
Постоянное поколение: Этот пул памяти как имя также содержит информацию о метаданных и дескрипторах постоянного класса, поэтому пространство PermGen всегда зарезервировано для классов и тех, которые привязаны к классам, например, статическим членам.
Обновление Java8: PermGen заменяется на Metaspace, который очень похож.
Основное различие заключается в том, что Metaspace изменяет размеры динамически, т.е. Он может расширяться во время выполнения.
Java Metaspace space: unbounded (по умолчанию)
Кэш-код (виртуальный или зарезервированный): если вы используете HotSpot Java VM, это включает область кеша кода, содержащую память, которая будет использоваться для компиляции и хранения собственного кода.
Что такое молодое поколение?
Молодое поколение - это место, где все новые объекты выделены и поставлены. Когда молодое поколение заполняется, это вызывает небольшую сборку мусора. Молодое поколение, полное мертвых объектов, собирается очень быстро. Некоторые выжившие объекты стареют и в конечном итоге переходят к старому поколению.
Что такое старое поколение?
Старое поколение используется для хранения долгоживущих объектов. Как правило, для объекта молодого поколения устанавливается порог, и когда этот возраст встречается, объект перемещается в прежнее поколение. В конечном итоге необходимо собрать новое поколение. Это событие называется основной сборкой мусора
Что такое постоянное поколение?
Постоянное поколение содержит метаданные, требуемые JVM для описания классов и методов, используемых в приложении. Постоянное поколение заполняется JVM во время выполнения на основе классов, используемых приложением.
PermGen был заменен на Metaspace с версии Java 8.
Параметры PermSize и MaxPermSize будут теперь игнорироваться
Как три поколения взаимодействуют/связаны друг с другом?
Источник изображения и статьи о технике оракула: http://www.oracle.com/webfolder/technetwork/tutorials/obe/java/gc01/index.html
"Общий процесс сбора мусора" в приведенной выше статье объясняет взаимодействие между ними со многими диаграммами.
Посмотрите на итоговую диаграмму:
Виртуальная машина Java состоит из трех поколений: молодого поколения, старого поколения и постоянного поколения. Большинство объектов изначально выделяются в молодое поколение. Старое поколение содержит объекты, которые пережили некоторое количество коллекций молодого поколения, а также некоторые крупные объекты, которые могут быть выделены непосредственно в старом поколении. Постоянное поколение содержит объекты, которые JVM считает удобными для управления сборщиками мусора, такими как объекты, описывающие классы и методы, а также сами классы и методы.
Эта статья является очень хорошим обзором сборщиков мусора. Он определяет основные понятия и терминологию сбора мусора и включает множество пояснительных чертежей. Это "нужно читать" для тех, кто заинтересован в том, как работает автоматическое распределение памяти; чтение его значительно облегчит вам чтение и понимание различных документов, на которые указывают другие.
(В этом документе отсутствует какая-либо информация о проведенных в 1993 году исследованиях сборщиков мусора, особенно о бизнесе многоядерных систем. Тем не менее, вы должны научиться ходить, прежде чем научиться работать.)
Предполагая, что вы говорите о Sun JDK/OpenJDK, см. страницу на веб-сайте OpenJDK в Управление хранилищем. Есть несколько ссылок на еще большую информацию внизу.
Хотя речь идет о настройке, я не могу сопротивляться, рекомендую этот документ взглянуть на главу 3 и углубиться, если хотите.
Память в SunHotSpot JVM организована в три поколения: молодое поколение, старое поколение и постоянное поколение.
FYI: постоянный ген не считается частью кучи Java.
Как три поколения взаимодействуют друг с другом? Объекты (кроме крупных) сначала выделяются молодому поколению. Если объект остается в живых после x no. циклов сбора мусора, он продвигается до старого поколения. Следовательно, мы можем сказать, что молодой ген содержит короткоживущие объекты, в то время как старый ген содержит объекты, имеющие долгую жизнь. Постоянный ген не взаимодействует с другими двумя поколениями.