Рубрики
Без рубрики

Модель памяти Java (JVM) – Управление памятью на Java

Управление памятью на Java. Модель памяти Java. Модель памяти JVM. Распределение памяти Java, Молодое поколение, Старое поколение, Постоянное поколение, Куча, Стек.

Автор оригинала: Pankaj Kumar.

Понимание Модели памяти JVM , Управления памятью Java очень важно, если вы хотите понять работу Сборки мусора Java . Сегодня мы рассмотрим управление памятью в Java, различные части памяти JVM и то, как отслеживать и выполнять настройку сборки мусора.

Модель памяти Java (JVM)

Как вы можете видеть на приведенном выше изображении, память JVM разделена на отдельные части. На широком уровне память кучи JVM физически разделена на две части – Молодое поколение и Старое поколение .

Управление памятью на Java – Молодое поколение

Молодое поколение-это место, где создаются все новые объекты. Когда молодое поколение заполняется, производится сбор мусора. Эта сборка мусора называется Minor GC . Молодое поколение разделено на три части – Память Эдема и две Память выживших пространства.

Важные моменты, касающиеся пространств для молодого поколения:

  • Большинство вновь созданных объектов находятся в пространстве памяти Eden.
  • Когда пространство Eden заполняется объектами, выполняется незначительная сборка, и все объекты, оставшиеся в живых, перемещаются в одно из пространств, оставшихся в живых.
  • Второстепенный GC также проверяет объекты выживших и перемещает их в другое пространство выживших. Таким образом, за один раз одно из оставшихся в живых мест всегда пустует.
  • Объекты, которые сохранились после многих циклов GC, перемещаются в пространство памяти старого поколения. Обычно это делается путем установления порогового значения возраста объектов молодого поколения, прежде чем они получат право на продвижение к старому поколению.

Управление памятью в Java – Старое поколение

Память старого поколения содержит объекты, которые являются долгоживущими и сохранились после многих раундов незначительной GC. Обычно сборка мусора выполняется в памяти старого поколения, когда она заполнена. Сборка мусора старого поколения называется Major GC и обычно занимает больше времени.

Остановите Мировое событие

Все сборки мусора являются событиями “Остановить мир”, потому что все потоки приложений останавливаются до завершения операции.

Поскольку молодое поколение хранит недолговечные объекты, незначительная GC выполняется очень быстро, и это не влияет на приложение.

Однако основная GC занимает много времени, потому что она проверяет все живые объекты. Основные операции GC должны быть сведены к минимуму, поскольку это приведет к тому, что ваше приложение не будет отвечать на запросы во время сбора мусора. Поэтому, если у вас есть отзывчивое приложение и происходит много крупных операций по сбору мусора, вы заметите ошибки тайм-аута.

Продолжительность, затрачиваемая сборщиком мусора, зависит от стратегии, используемой для сбора мусора. Вот почему необходимо отслеживать и настраивать сборщик мусора, чтобы избежать тайм-аутов в приложениях с высокой чувствительностью.

Модель памяти Java – Постоянное поколение

Постоянное поколение или “PermGen” содержит метаданные приложения, необходимые JVM для описания классов и методов, используемых в приложении. Обратите внимание, что PermGen не является частью памяти кучи Java.

Пермское поколение заполняется JVM во время выполнения на основе классов, используемых приложением. Perm Gen также содержит классы и методы библиотеки Java SE. Объекты пермского поколения-это мусор, собранный в полной сборке мусора.

Модель памяти Java – Область Методов

Область методов является частью пространства в PermGen и используется для хранения структуры классов (констант времени выполнения и статических переменных) и кода для методов и конструкторов.

Модель памяти Java – Пул памяти

Пулы памяти создаются менеджерами памяти JVM для создания пула неизменяемых объектов, если реализация поддерживает это. Пул строк-хороший пример такого пула памяти. Пул памяти может принадлежать куче или PermGen, в зависимости от реализации диспетчера памяти JVM.

Модель памяти Java – Пул констант времени Выполнения

Пул констант времени выполнения-это представление во время выполнения для каждого класса пула констант в классе. Он содержит константы времени выполнения класса и статические методы. Пул констант времени выполнения является частью области методов.

Модель памяти Java – Память стека Java

Память стека Java используется для выполнения потока. Они содержат кратковременные значения для конкретного метода и ссылки на другие объекты в куче, на которые ссылается метод. Вы должны прочитать Разницу между стековой и кучной памятью .

Управление памятью в Java – Переключатели памяти кучи Java

Java предоставляет множество переключателей памяти, которые мы можем использовать для установки размеров памяти и их соотношений. Некоторые из часто используемых переключателей памяти являются:

-Xms Для установки начального размера кучи при запуске JVM
-Xmx Для установки максимального размера кучи.
-Xmn Для определения численности молодого поколения остальная часть пространства отводится Старому поколению.
-XX:ПермГен Для установки начального размера постоянной памяти поколения
-XX:MaxPermGen Для установки максимального размера PermGen
-XX:Выживание Для обеспечения соотношения пространства Эдема и пространства Выживших, например, если размер молодого поколения составляет 10 м, а переключатель виртуальной машины равен 5 м, то для пространства Эдема будет зарезервировано 5 м, а для обоих пространств Выживших-по 2,5 м. Значение по умолчанию равно 8.
-XX:Новое время Для обеспечения соотношения размеров старого/нового поколения. Значение по умолчанию равно 2.

В большинстве случаев вышеуказанных опций достаточно, но если вы хотите проверить и другие опции, пожалуйста, проверьте Официальную страницу опций JVM .

Управление памятью в Java – Сборка мусора Java

Сборка мусора Java-это процесс идентификации и удаления неиспользуемых объектов из памяти и свободного пространства, которые будут выделены объектам, созданным в ходе будущей обработки. Одной из лучших особенностей языка программирования Java является автоматическая сборка мусора , в отличие от других языков программирования, таких как C, где выделение и освобождение памяти выполняется вручную.

Сборщик мусора – это программа, работающая в фоновом режиме, которая просматривает все объекты в памяти и обнаруживает объекты, на которые не ссылается ни одна часть программы. Все эти объекты без ссылок удаляются, а пространство освобождается для выделения другим объектам.

Один из основных способов сбора мусора включает в себя три этапа:

  1. Маркировка : Это первый шаг, на котором сборщик мусора определяет, какие объекты используются, а какие нет.
  2. Обычное удаление : Сборщик мусора удаляет неиспользуемые объекты и освобождает свободное пространство, которое будет выделено другим объектам.
  3. Удаление с уплотнением : Для повышения производительности после удаления неиспользуемых объектов все уцелевшие объекты можно переместить, чтобы они были вместе. Это повысит производительность выделения памяти более новым объектам.

Есть две проблемы с простым подходом к пометке и удалению.

  1. Во – первых, это неэффективно, потому что большинство вновь созданных объектов станут неиспользуемыми
  2. Во-вторых, объекты, используемые для нескольких циклов сборки мусора, скорее всего, будут использоваться и для будущих циклов.

Вышеуказанные недостатки при простом подходе являются причиной того, что Сборка мусора Java является поколенческой и у нас есть Молодое поколение и Старое поколение места в памяти кучи. Я уже объяснял выше, как объекты сканируются и перемещаются из одного пространства поколений в другое на основе второстепенного GC и Основного GC.

Управление памятью в Java – Типы сборки мусора Java

Существует пять типов сбора мусора, которые мы можем использовать в наших приложениях. Нам просто нужно использовать переключатель JVM, чтобы включить стратегию сбора мусора для приложения. Давайте рассмотрим каждый из них по очереди.

  1. Последовательный GC (-XX:+UseSerialGC) : Последовательный GC использует простой компактный подход для сбора мусора молодого и старого поколений, т. е. Второстепенный и основной GC.Последовательный GC полезен на клиентских машинах, таких как наши простые автономные приложения и машины с меньшим процессором. Он хорош для небольших приложений с низким объемом памяти.
  2. Параллельный GC (-XX:+UseParallelGC) : Параллельный GC такой же, как последовательный GC, за исключением того, что он порождает N потоков для сборки мусора молодого поколения, где N-количество ядер процессора в системе. Мы можем контролировать количество потоков, используя параметр -XX:ParallelGCThreads=n JVM.Параллельный сборщик мусора также называется сборщиком пропускной способности, поскольку он использует несколько процессоров для ускорения производительности GC. Параллельная сборка мусора использует один поток для сбора мусора старого поколения.
  3. Параллельный старый GC (-XX:+UseParallelOldGC) : Это то же самое, что и параллельный GC, за исключением того, что он использует несколько потоков как для сбора мусора молодого поколения, так и для сбора мусора старого поколения.
  4. Коллектор параллельной развертки метки (CMS) (- XX:+UseConcMarkSweepGC) : Коллектор CMS также называется коллектором параллельной низкой паузы. Он занимается сбором мусора для старого поколения. Сборщик CMS пытается свести к минимуму паузы из-за сборки мусора, выполняя большую часть работы по сборке мусора одновременно с потоками приложений.Коллектор CMS для молодого поколения использует тот же алгоритм, что и у параллельного коллектора. Этот сборщик мусора подходит для адаптивных приложений, в которых мы не можем позволить себе более длительные паузы. Мы можем ограничить количество потоков в сборщике CMS, используя параметр -XX:ParallelCMSThreads=n JVM.
  5. Сборщик мусора G1 (-XX:+UseG1GC) : Первый сборщик мусора или сборщик мусора G1 доступен в Java 7, и его долгосрочная цель-заменить сборщик CMS. Сборщик G1 – это параллельный, параллельный и постепенно уплотняющийся сборщик мусора с низкой задержкой.Первый сборщик мусора работает не так, как другие сборщики, и нет понятия пространства для молодых и старых поколений. Он делит пространство кучи на несколько областей кучи одинакового размера. Когда вызывается сборка мусора, она сначала собирает регион с меньшими оперативными данными, следовательно, “Сначала мусор”. Вы можете найти более подробную информацию об этом в документации Oracle по сборщику мусора .

Управление памятью в Java – Мониторинг сборки мусора Java

Мы можем использовать командную строку Java, а также инструменты пользовательского интерфейса для мониторинга действий по сбору мусора в приложении. Для моего примера я использую одно из демонстрационных приложений, предоставляемых загрузками Java SE.

Если вы хотите использовать одно и то же приложение, перейдите на страницу Загрузки Java SE и загрузите Демонстрации и образцы JDK 7 и JavaFX . Пример приложения, которое я использую, это Java2Demo.jar и он присутствует в каталоге jdk1.7.0_55/demo/jfc/Java2D . Однако это необязательный шаг, и вы можете запускать команды мониторинга GC для любого приложения java.

Команда, используемая мной для запуска демонстрационного приложения, является:

pankaj@Pankaj:~/Downloads/jdk1.7.0_55/demo/jfc/Java2D$ java -Xmx120m -Xms30m -Xmn10m -XX:PermSize=20m -XX:MaxPermSize=20m -XX:+UseSerialGC -jar Java2Demo.jar

jstat

Мы можем использовать jstat инструмент командной строки для мониторинга памяти JVM и операций по сбору мусора. Он поставляется со стандартным JDK, так что вам не нужно ничего делать, чтобы его получить.

Для выполнения jstat вам необходимо знать идентификатор процесса приложения, вы можете легко его получить, используя команду ps-eaf | grep java .

pankaj@Pankaj:~$ ps -eaf | grep Java2Demo.jar
  501 9582  11579   0  9:48PM ttys000    0:21.66 /usr/bin/java -Xmx120m -Xms30m -Xmn10m -XX:PermSize=20m -XX:MaxPermSize=20m -XX:+UseG1GC -jar Java2Demo.jar
  501 14073 14045   0  9:48PM ttys002    0:00.00 grep Java2Demo.jar

Таким образом, идентификатор процесса для моего java – приложения равен 9582. Теперь мы можем запустить команду jstat , как показано ниже.

pankaj@Pankaj:~$ jstat -gc 9582 1000
 S0C    S1C    S0U    S1U      EC       EU        OC         OU       PC     PU    YGC     YGCT    FGC    FGCT     GCT
1024.0 1024.0  0.0    0.0    8192.0   7933.3   42108.0    23401.3   20480.0 19990.9    157    0.274  40      1.381    1.654
1024.0 1024.0  0.0    0.0    8192.0   8026.5   42108.0    23401.3   20480.0 19990.9    157    0.274  40      1.381    1.654
1024.0 1024.0  0.0    0.0    8192.0   8030.0   42108.0    23401.3   20480.0 19990.9    157    0.274  40      1.381    1.654
1024.0 1024.0  0.0    0.0    8192.0   8122.2   42108.0    23401.3   20480.0 19990.9    157    0.274  40      1.381    1.654
1024.0 1024.0  0.0    0.0    8192.0   8171.2   42108.0    23401.3   20480.0 19990.9    157    0.274  40      1.381    1.654
1024.0 1024.0  48.7   0.0    8192.0   106.7    42108.0    23401.3   20480.0 19990.9    158    0.275  40      1.381    1.656
1024.0 1024.0  48.7   0.0    8192.0   145.8    42108.0    23401.3   20480.0 19990.9    158    0.275  40      1.381    1.656

Последним аргументом для jstat является интервал времени между каждым выводом, поэтому он будет печатать данные о памяти и сборке мусора каждые 1 секунду.

Давайте пройдемся по каждой колонке по очереди.

  • S0C и S1C : В этом столбце показан текущий размер областей Выжившего 0 и Выжившего 1 в КБ.
  • S0 и S1U : В этом столбце показано текущее использование областей Выживший 0 и Выживший 1 в КБ. Обратите внимание, что одна из областей выживших все время пуста.
  • ЕС и ЕС : Эти столбцы показывают текущий размер и использование пространства Eden в КБ. Обратите внимание, что размер ЕС увеличивается, и как только он пересекает ЕС, вызывается Второстепенный GC и размер ЕС уменьшается.
  • OC и OU : Эти столбцы показывают текущий размер и текущее использование старого поколения в КБ.
  • PC и PU : В этих столбцах показан текущий размер и текущее использование PermGen в КБ.
  • YGC и YGC : в столбце YGC отображается количество событий GC, произошедших в молодом поколении. В столбце YGCT отображается накопленное время для операций GC для молодого поколения. Обратите внимание, что оба они увеличены в одной строке, где значение EU уменьшается из-за незначительного GC.
  • FGC и FGC : в столбце FGC отображается количество произошедших полных событий GC. В столбце FGCT отображается накопленное время для полных операций GC. Обратите внимание, что полное время GC слишком велико по сравнению с временем GC молодого поколения.
  • GCT : В этом столбце отображается общее накопленное время для операций GC. Обратите внимание, что это сумма значений столбцов GCT и GCT.

Преимущество jstat в том, что он также может быть выполнен на удаленных серверах, где у нас нет графического интерфейса. Обратите внимание, что сумма S0C, S1C и EC составляет 10 м, как указано в параметре -Xmn10m JVM.

Java VisualVM с визуальным GC

Если вы хотите видеть операции с памятью и GC в графическом интерфейсе, вы можете использовать jvisualvm инструмент. Java VisualVM также является частью JDK, поэтому вам не нужно загружать его отдельно.

Просто запустите команду jvisualvm в терминале, чтобы запустить приложение Java VisualVM. После запуска вам необходимо установить Visual GC плагин с помощью опции Tools -< Плагины, как показано на рисунке ниже.

После установки Visual GC просто откройте приложение в левой боковой колонке и перейдите в раздел Visual GC . Вы получите изображение памяти JVM и сведения о сборке мусора, как показано на рисунке ниже.

Настройка Сборки мусора Java

Настройка сборки мусора Java должна быть последней опцией, которую вы должны использовать для увеличения пропускной способности вашего приложения, и только тогда, когда вы видите снижение производительности из-за более длительных периодов времени GC, вызывающих тайм-аут приложения.

Если вы видите java.lang.OutOfMemoryError: пространство PermGen ошибки в журналах, затем попробуйте отслеживать и увеличивать пространство памяти PermGen, используя параметры-XX:PermGen и -XX:MaxPermGen JVM. Вы также можете попробовать использовать -XX:+CMSClassUnloadingEnabled и проверить, как он работает с сборщиком мусора CMS.

Если вы видите много полных операций GC, то вам следует попробовать увеличить объем памяти старого поколения.

Общая настройка сборки мусора требует много усилий и времени, и для этого нет жестких и быстрых правил. Вам нужно будет попробовать различные варианты и сравнить их, чтобы найти лучший, подходящий для вашего приложения.

Это все для модели памяти Java, управления памятью в Java и сбора мусора, я надеюсь, что это поможет вам понять память JVM и процесс сбора мусора.