16 Убитых java $JVM_OPTS -jar app.jar

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

Кто убийца?
Каков мотив?
Что это за оружие?
Как мы могли бы предотвратить подобные убийства в будущем?

Тайна убийства

Оружие

Это сообщение, которое никто бы не осмелился назвать подробным, печатается, когда JVM получает сигнал и у него нет другого выбора, кроме как умереть. Существует только 1 сигнал такой мощности – это SIGKILL . Это мрачный жнец процессов, и полноразмерные сникерсы могут дать вам только столько времени – на самом деле даже недостаточно, чтобы попрощаться со всеми вашими родственниками.

Убийца

У СИГКИЛЛА может быть несколько источников происхождения:

кто-то выдал убийство -9
какой-то другой процесс вызвал системный вызов signal() и отправил сигнал SIGKILL на вашу виртуальную машину
Убийца ООМ

Мотив

Как и в реальной жизни, у каждого убийцы может быть свой мотив.

kill -9 может быть разработчиком, системным администратором или злоумышленником, вошедшим в системную оболочку, выполняющим команду. Почему? Спросите его/ее. Возможно, это была ошибка, и команде был передан неправильный PID. Возможно, JVM оказалась застрявшей/замороженной и нуждалась в перезапуске. Возможно, JVM израсходовала слишком много ресурсов (особенно в общих средах) и не оставила места для других приложений. Возможно, на сервере происходило какое-то техническое обслуживание. Могли быть и другие причины. Поэтому войдите в систему, выполните команду last и посмотрите, кто вошел в систему в то время. И прочтите ему/ей хорошую лекцию о том, почему следует избегать использования SIGKILL (убить -9) (простого убийства или убийства -15 должно быть достаточно).
сигнал() это довольно необычно и вряд ли произойдет. Однако маловероятное не значит невозможное. Если у вас есть другие приложения, запущенные в этой системе, скорее всего, в некоторых из них может быть ошибка и вы выберете неправильный PID в качестве приемника сигнала. Я сталкивался с таким случаем только один раз в своей ИТ-карьере, и виноват был демон мониторинга.

РЕДАКТИРОВАТЬ: Поскольку мы живем во времена контейнеризации, вы также можете увидеть, что в контейнерах происходят сбои. Они могут возникать, когда оркестратор (например, Kubernetes) принудительно завершает работу контейнера. Хотя k8s милосерден и дает приложению шанс выйти из строя изящно – k8s сначала отправляет SIGTERM, и, если приложение все еще работает после льготного периода, только тогда k8s уничтожает его с помощью KILL… Если это произошло, то, скорее всего, либо проверка работоспособности/готовности вашего приложения не удалась слишком много раз, либо планировщик k8s переместил этот модуль на другой узел. Также может произойти неожиданное отключение узла (например, перебалансировка AWS между AZ).

У LOOK (Убийцы из памяти) есть только 1 мотив – ОС почувствовала угрозу, что у нее не останется достаточно памяти, чтобы дышать, и вызвала УМК, чтобы провести некоторую очистку. Это наиболее вероятная причина ваших отключений. Если у вас есть доступы, вы можете подтвердить эту теорию, изучив последние записи в выводе dmesg . Если вы видите там запись “Убитый процесс 4832 (java)” вместе с некоторыми таблицами расположения памяти, значит, вы нашли своего убийцу.

Убийца ООМ – Мрачный Жнец из земли Ядра

Операционная система (Операционная система)

Это магия , которая работает на вашем компьютере. Операционная система – это уровень взаимодействия между устройствами ввода компьютера и устройствами вывода. Когда вы набираете букву “а” на клавиатуре, ОС решает, что происходит на вашем экране, компакт-диске и динамиках. Можно было бы возразить, что это зависит от открытого приложения, и это тоже было бы правильно. Дело в том, что термин “ОС” настолько обширен, что включает в себя практически все программное обеспечение: приложения, драйверы, терминал, установщики и так далее. На вашем компьютере есть определенные типы программного обеспечения, которые не являются частью операционной системы (микрокод/прошивка, BIOS/EFI и тому подобное). Операционная система разделена на 2 основные части: ядро и пользовательское пространство.

Земля ядра

Пространство ядра – это гора Олимп операционной системы. Это место, где живут боги. В некотором смысле… Это ядро операционной системы. Это автономная система, которая преобразует аппаратное обеспечение в программное обеспечение и обратно. Это сложная многоуровневая система, которая обнаруживает и использует ваши аппаратные компоненты для выполнения того, что требует от них ваше программное обеспечение. Ядро – это “парень”, который может предоставить вам ресурсы, необходимые для ваших приложений, такие как память, процессорное время, сеть и т.д. Если ядро выходит из строя – вся система выходит из строя.

Пользовательская страна

Пользовательское пространство – это место, где запущены все приложения: MS Word, java, cstrike16.exe , chrome.exe и др. Вы можете перечислить эти приложения с помощью ps или сверху , следить за их деятельностью, даже шпионить за ними с помощью strace и отслеживать ! Это также место, где корень и другие пользователи живут в.

Проблема

Проблема в том, что и ядро, и приложения пользовательского пространства используют один и тот же пул ресурсов. Области памяти не разделены строго (для большей части), и возможно, что утечка памяти в каком-либо приложении пользовательского пространства будет занимать всю память. Также возможно (хотя и гораздо менее вероятно), что утечка памяти в каком-либо модуле ядра (например, в каком-либо драйвере) будет потреблять оперативную память. В любом случае, как пространство пользователя, так и пространство ядра будут голодать. Если пользовательское пространство голодает – приложения зависают. Но если пространство ядра истощается – вся система выходит из строя. Существуют методы управления нехваткой памяти, такие как использование подкачки в качестве расширения оперативной памяти, но эти методы не решают актуальную проблему.

Ядро ненавидит голодание

На самом деле, он ненавидит это так сильно, что готов действительно убить, если почувствует эту угрозу. Поскольку память является общим ресурсом, у ядра есть некоторые средства защиты от нехватки оперативной памяти. Эти методы вызывают проблемы в пользовательском пространстве, но они поддерживают работоспособность системы. Тот, кто может нанести наибольший вред вашим приложениям, – это убийца из памяти – ООМК. Ядро постоянно следит за использованием памяти. Если использование памяти становится слишком высоким и остается всего несколько процентов многоразовой (многоразовой > свободной) памяти, ядро чувствует угрозу и вызывает OOMK. В КНИГЕ рассматриваются все процессы в пользовательском пространстве, проверяется использование их памяти и применяются некоторые формулы для расчета коэффициента умк. Затем он выбирает процесс с наибольшим коэффициентом и посылает сигнал SIGKILL на свой PID. У процесса нет возможности ответить на это событие или пережить его, и он должен умереть. Обычно процесс с наибольшим коэффициентом загрузки – это процесс с наибольшим использованием памяти (RSS).

Подталкивание другого процесса под автобус

Однако существуют кнопки и рычаги для настройки расчета коэффициента oomk: если ваше java-приложение запускает несколько рабочих процессов, например, процессы soffice для преобразования docx в pdf, вы можете предпочесть, чтобы OOMK уничтожал процессы soffice, а не вашу JVM. Этого можно достичь, соответствующим образом настроив процессы после их запуска. echo -17 >/процесс//oom_adj echo -17 >/proc//oom_adj сделает так, чтобы ваша JVM получила минимально возможное соотношение echo 15 >/proc//oom_adj

|| echo -17 >/proc//oom_adj || сделает так, чтобы ваша JVM получила минимально возможное соотношение oomk || echo 15 >/proc//oom_adj || сделает так, чтобы ваши процессы sofice получили максимально возможное соотношение oomk. В результате, когда придет время, БУМ, скорее всего, убьет процесс soffice вместо вашего java-приложения. Превентивные меры

|| echo -17 >/proc//oom_adj || сделает так, чтобы ваша JVM получила минимально возможное соотношение oomk || echo 15 >/proc//oom_adj || сделает так, чтобы ваши процессы sofice получили максимально возможное соотношение oomk. В результате, когда придет время, БУМ, скорее всего, убьет процесс soffice вместо вашего java-приложения. Меры по предотвращению Лучший способ не дать ООМК спать спокойно – это иметь память. Кроме того, при разработке функции можно не учитывать некоторые варианты использования или нюансы среды, которые могут привести к чрезмерному использованию памяти JAVA/JVM. Однако случаются ошибки, и утечки памяти являются встроенными функциями. использование ry под контролем.

|| echo -17 >/proc//oom_adj || сделает так, чтобы ваша JVM получила минимально возможное соотношение oomk || echo 15 >/proc//oom_adj || сделает так, чтобы ваши процессы sofice получили максимально возможное соотношение oomk. В результате, когда придет время, БУМ, скорее всего, убьет процесс soffice вместо вашего java-приложения. Меры по предотвращению Лучший способ не дать ООМК спать спокойно – это иметь память. Кроме того, при разработке функции можно не учитывать некоторые варианты использования или нюансы среды, которые могут привести к аномальному использованию пулов памяти Java/JVM с большим объемом памяти. Однако случаются ошибки, и утечки памяти являются встроенными функциями. использование ry под контролем.

echo -17 >/proc//oom_adj

echo -17 >/proc//oom_adj
сделает так, чтобы ваша JVM получила минимально возможное соотношение oomk echo 15 >/proc//oom_adj сделает так, чтобы ваши процессы sofice получили максимально возможное соотношение oomk. В результате, когда придет время, OOMK, скорее всего, убьет процесс soffice вместо вашего java-приложения. Меры по предотвращению Лучший способ обеспечить спокойный сон OOMK – это иметь память. Кроме того, при разработке функции можно не учитывать некоторые варианты использования или нюансы среды, которые могут привести к сбоям. JVM – исключительно хороший механизм для сохранения пулов памяти вашего MEIT, большинство из которых могут быть ограничены. мори использует сам код uJVM – JVM также является приложением, и для его работы требуется память, для запуска байт-кода java память без кучи содержит такие вещи, как Не куча – это “все остальное”. Легко, верно? Это запустит JVM и ограничит использование кучи максимум 4 ГБ. например
java -Xmx4g -jar-файл app.jar
- Стандартный способ установить это ограничение – запустить JVM с опцией -Xmx, куча может быть жестко ограничена, чтобы никогда не превышать некоторый предопределенный предел. Далее он разделен на несколько разделов, но мы не будем останавливаться на этом в этой статье. Куча – это место, где живут все
- новые объекты. память JVM, не относящаяся к куче, делится на: управление поиском. Пулы памяти Java/JVM используют слишком много памяти. Однако случаются ошибки, и утечки памяти являются встроенными функциями. использование ry под контролем.

|| echo -17 >/proc//oom_adj || сделает так, чтобы ваша JVM получила минимально возможное соотношение oomk || echo 15 >/proc//oom_adj || сделает так, чтобы ваши процессы sofice получили максимально возможное соотношение oomk. В результате, когда придет время, OOMK, скорее всего, убьет процесс soffice вместо вашего java-приложения. Меры по предотвращению Лучший способ обеспечить спокойный сон OOMK – это иметь память. Кроме того, при разработке функции можно не учитывать некоторые варианты использования или нюансы среды, которые могут привести к сбоям. JVM – исключительно хороший механизм для сохранения пулов памяти вашего MEIT, большинство из которых могут быть ограничены. использование памяти Проблема с памятью вне кучи заключается в том, что ее трудно контролировать и ограничивать. Он выделяет буфер непосредственно в памяти, минуя GC, что делает этот буфер быстрее, но чем больше и чем больше у вас буферов, тем больше вероятность того, что вы будете потреблять память, которая не будет видна в куче. Наиболее знакомым примером таких структур данных является java NIO || DirectByteBuffer, к которому даже GC не может прикоснуться. Управлять его памятью зависит только от этого собственного кода. И если специально не запрошено, эта память будет выделена за пределами кучи. Собственные библиотеки, скорее всего, будут потреблять некоторое количество памяти. собственные структуры данных. Пожалуйста, имейте в виду, что ваши зависимости от java также могут зависеть от некоторого собственного кода. Чем больше у вас собственных библиотек, тем больше свободной памяти будет потреблять ваша JVM. Они хранятся в областях памяти, не связанных с кучей. Эти вложенные приложения компилируются в .so/.dll библиотеки и загружаются в JVM. собственные библиотеки – с помощью JNI/JNA разработчики могут подключаться к написанию java-приложений, которые выполняют код C/C++. в машинном коде все значения параметров помещаются в стек, а затем вызывается функция, и каждый раз, когда вы ссылаетесь на параметр в этой функции, вы считываете его из пространства стека. Наряду с последовательностью вызовов в стеке также хранятся параметры функций. Записи стека добавляются при вызове функции и удаляются при вызове || return || или возникновении исключения. Там вы можете увидеть, какие функции вызывают какие функции, и, собственно, всю цепочку вызовов. Это очень хорошо видно в дампах потоков/трассировках стека. стеки потоков – точно так же, как в asm, C и других языках более низкого уровня, вызовы процессов/потоков складываются вместе. Чем больше у вас классов, тем больше и больше у них статических полей, тем больше памяти они будут потреблять. Поскольку классы обычно не изменяются приложениями, они хранятся в областях статической памяти. загруженные классы – загрузчики классов также загружают классы в память. Сам код JVM – JVM также является приложением, и для его работы требуется память, для запуска байт-кода java память без кучи содержит такие вещи, как Не куча – это “все остальное”. Легко, верно? Это запустит JVM и ограничит использование кучи максимум 4 ГБ. например, || java -Xmx4g -jar app.jar || Стандартный способ установить это ограничение – запустить JVM с опцией -Xmx, куча может быть жестко ограничена, чтобы никогда не превышать некоторый заранее установленный предел. Далее он разделен на несколько разделов, но мы не будем останавливаться на этом в этой статье. Куча – это место, где живут все || новые || объекты. память JVM, не относящаяся к куче, делится на: управление поиском. Пулы памяти Java/JVM используют слишком много памяти. Однако случаются ошибки, и утечки памяти являются встроенными функциями. использование ry под контролем. || echo -17 >/proc//oom_adj || сделает так, чтобы ваша JVM получила минимально возможное соотношение oomk || echo 15 >/proc//oom_adj || сделает так, чтобы ваши процессы sofice получили максимально возможное соотношение oomk. В результате, когда придет время, OOMK, скорее всего, убьет процесс soffice вместо вашего java-приложения. Меры по предотвращению Лучший способ обеспечить спокойный сон OOMK – это иметь память. Кроме того, при разработке функции можно не учитывать некоторые варианты использования или нюансы среды, которые могут привести к сбоям. JVM – исключительно хороший механизм для сохранения пулов памяти вашего MEIT, большинство из которых могут быть ограничены. в некотором смысле, эта часть памяти JVM не ограничена и в основном невидима. Проблема с памятью вне кучи заключается в том, что ее трудно контролировать и ограничивать. Он выделяет буфер непосредственно в памяти, минуя GC, что делает этот буфер быстрее, но чем больше и чем больше у вас буферов, тем больше вероятность того, что вы будете потреблять память, которая не будет видна в куче. Наиболее знакомым примером таких структур данных является java NIO || DirectByteBuffer, к которому даже GC не может прикоснуться. Управлять его памятью зависит только от этого собственного кода. И если специально не запрошено, эта память будет выделена за пределами кучи. Собственные библиотеки, скорее всего, будут потреблять некоторое количество памяти. собственные структуры данных. Пожалуйста, имейте в виду, что ваши зависимости от java также могут зависеть от некоторого собственного кода. Чем больше у вас собственных библиотек, тем больше свободной памяти будет потреблять ваша JVM. Они хранятся в областях памяти, не связанных с кучей. Эти вложенные приложения компилируются в .so/.dll библиотеки и загружаются в JVM. собственные библиотеки – с помощью JNI/JNA разработчики могут подключаться к написанию java-приложений, которые выполняют код C/C++. в машинном коде все значения параметров помещаются в стек, а затем вызывается функция, и каждый раз, когда вы ссылаетесь на параметр в этой функции, вы считываете его из пространства стека. Наряду с последовательностью вызовов в стеке также хранятся параметры функций. Записи стека добавляются при вызове функции и удаляются при вызове || return || или возникновении исключения. Там вы можете увидеть, какие функции вызывают какие функции, и, собственно, всю цепочку вызовов. Это очень хорошо видно в дампах потоков/трассировках стека. стеки потоков – точно так же, как в asm, C и других языках более низкого уровня, вызовы процессов/потоков складываются вместе. Чем больше у вас классов, тем больше и больше у них статических полей, тем больше памяти они будут потреблять. Поскольку классы обычно не изменяются приложениями, они хранятся в областях статической памяти. загруженные классы – загрузчики классов также загружают классы в память. Сам код JVM – JVM также является приложением, и для его работы требуется память, для запуска байт-кода java память без кучи содержит такие вещи, как Не куча – это “все остальное”. Легко, верно? Это запустит JVM и ограничит использование кучи максимум 4 ГБ. например, || java -Xmx4g -jar app.jar || Стандартный способ установить это ограничение – запустить JVM с опцией -Xmx, куча может быть жестко ограничена, чтобы никогда не превышать некоторый заранее установленный предел. Далее он разделен на несколько разделов, но мы не будем останавливаться на этом в этой статье. Куча – это место, где живут все || новые || объекты. память JVM, не относящаяся к куче, делится на: управление поиском. Пулы памяти Java/JVM используют слишком много памяти. Однако случаются ошибки, и утечки памяти являются встроенными функциями. использование ry под контролем.

|| echo -17 >/proc//oom_adj || сделает так, чтобы ваша JVM получила минимально возможное соотношение oomk || echo 15 >/proc//oom_adj || сделает так, чтобы ваши процессы sofice получили максимально возможное соотношение oomk. В результате, когда придет время, OOMK, скорее всего, убьет процесс soffice вместо вашего java-приложения. Меры по предотвращению Лучший способ обеспечить спокойный сон OOMK – это иметь память. Кроме того, при разработке функции можно не учитывать некоторые варианты использования или нюансы среды, которые могут привести к сбоям. JVM – исключительно хороший механизм для сохранения пулов памяти вашего MEIT, большинство из которых могут быть ограничены. использование памяти Мониторинг использования памяти В некотором смысле эта часть памяти виртуальной машины не ограничена и в основном невидима. Проблема с памятью вне кучи заключается в том, что ее трудно контролировать и ограничивать. Он выделяет буфер непосредственно в памяти, минуя GC, что делает этот буфер быстрее, но чем больше и чем больше у вас буферов, тем больше вероятность того, что вы будете потреблять память, которая не будет видна в куче. Наиболее знакомым примером таких структур данных является java NIO || DirectByteBuffer, к которому даже GC не может прикоснуться. Управлять его памятью зависит только от этого собственного кода. И если специально не запрошено, эта память будет выделена за пределами кучи. Собственные библиотеки, скорее всего, будут потреблять некоторое количество памяти. собственные структуры данных. Пожалуйста, имейте в виду, что ваши зависимости от java также могут зависеть от некоторого собственного кода. Чем больше у вас собственных библиотек, тем больше свободной памяти будет потреблять ваша JVM. Они хранятся в областях памяти, не связанных с кучей. Эти вложенные приложения компилируются в .so/.dll библиотеки и загружаются в JVM. собственные библиотеки – с помощью JNI/JNA разработчики могут подключаться к написанию java-приложений, которые выполняют код C/C++. в машинном коде все значения параметров помещаются в стек, а затем вызывается функция, и каждый раз, когда вы ссылаетесь на параметр в этой функции, вы считываете его из пространства стека. Наряду с последовательностью вызовов в стеке также хранятся параметры функций. Записи стека добавляются при вызове функции и удаляются при вызове || return || или возникновении исключения. Там вы можете увидеть, какие функции вызывают какие функции, и, собственно, всю цепочку вызовов. Это очень хорошо видно в дампах потоков/трассировках стека. стеки потоков – точно так же, как в asm, C и других языках более низкого уровня, вызовы процессов/потоков складываются вместе. Чем больше у вас классов, тем больше и больше у них статических полей, тем больше памяти они будут потреблять. Поскольку классы обычно не изменяются приложениями, они хранятся в областях статической памяти. загруженные классы – загрузчики классов также загружают классы в память. Сам код JVM – JVM также является приложением, и для его работы требуется память, для запуска байт-кода java память без кучи содержит такие вещи, как Не куча – это “все остальное”. Легко, верно? Это запустит JVM и ограничит использование кучи максимум 4 ГБ. например, || java -Xmx4g -jar app.jar || Стандартный способ установить это ограничение – запустить JVM с опцией -Xmx, куча может быть жестко ограничена, чтобы никогда не превышать некоторый заранее установленный предел. Далее он разделен на несколько разделов, но мы не будем останавливаться на этом в этой статье. Куча – это место, где живут все || новые || объекты. память JVM, не относящаяся к куче, делится на: управление поиском. Пулы памяти Java/JVM используют слишком много памяти. Однако случаются ошибки, и утечки памяти являются встроенными функциями. использование ry под контролем.

|| echo -17 >/proc//oom_adj || сделает так, чтобы ваша JVM получила минимально возможное соотношение oomk || echo 15 >/proc//oom_adj || сделает так, чтобы ваши процессы sofice получили максимально возможное соотношение oomk. В результате, когда придет время, OOMK, скорее всего, убьет процесс soffice вместо вашего java-приложения. Меры по предотвращению Лучший способ обеспечить спокойный сон OOMK – это иметь память. Кроме того, при разработке функции можно не учитывать некоторые варианты использования или нюансы среды, которые могут привести к сбоям. JVM – исключительно хороший механизм для сохранения пулов памяти вашего MEIT, большинство из которых могут быть ограничены. использование памяти uHeap Мониторинг использования памяти В некотором смысле эта часть памяти виртуальной машины не ограничена и в основном невидима. Проблема с памятью вне кучи заключается в том, что ее трудно контролировать и ограничивать. Он выделяет буфер непосредственно в памяти, минуя GC, что делает этот буфер быстрее, но чем больше и чем больше у вас буферов, тем больше вероятность того, что вы будете потреблять память, которая не будет видна в куче. Наиболее знакомым примером таких структур данных является java NIO || DirectByteBuffer, к которому даже GC не может прикоснуться. Управлять его памятью зависит только от этого собственного кода. И если специально не запрошено, эта память будет выделена за пределами кучи. Собственные библиотеки, скорее всего, будут потреблять некоторое количество памяти. собственные структуры данных. Пожалуйста, имейте в виду, что ваши зависимости от java также могут зависеть от некоторого собственного кода. Чем больше у вас собственных библиотек, тем больше свободной памяти будет потреблять ваша JVM. Они хранятся в областях памяти, не связанных с кучей. Эти вложенные приложения компилируются в .so/.dll библиотеки и загружаются в JVM. собственные библиотеки – с помощью JNI/JNA разработчики могут подключаться к написанию java-приложений, которые выполняют код C/C++. в машинном коде все значения параметров помещаются в стек, а затем вызывается функция, и каждый раз, когда вы ссылаетесь на параметр в этой функции, вы считываете его из пространства стека. Наряду с последовательностью вызовов в стеке также хранятся параметры функций. Записи стека добавляются при вызове функции и удаляются при вызове || return || или возникновении исключения. Там вы можете увидеть, какие функции вызывают какие функции, и, собственно, всю цепочку вызовов. Это очень хорошо видно в дампах потоков/трассировках стека. стеки потоков – точно так же, как в asm, C и других языках более низкого уровня, вызовы процессов/потоков складываются вместе. Чем больше у вас классов, тем больше и больше у них статических полей, тем больше памяти они будут потреблять. Поскольку классы обычно не изменяются приложениями, они хранятся в областях статической памяти. загруженные классы – загрузчики классов также загружают классы в память. Сам код JVM – JVM также является приложением, и для его работы требуется память, для запуска байт-кода java память без кучи содержит такие вещи, как Не куча – это “все остальное”. Легко, верно? Это запустит JVM и ограничит использование кучи максимум 4 ГБ. например, || java -Xmx4g -jar app.jar || Стандартный способ установить это ограничение – запустить JVM с опцией -Xmx, куча может быть жестко ограничена, чтобы никогда не превышать некоторый заранее установленный предел. Далее он разделен на несколько разделов, но мы не будем останавливаться на этом в этой статье. Куча – это место, где живут все || новые || объекты. память JVM, не относящаяся к куче, делится на: управление поиском. Пулы памяти Java/JVM используют слишком много памяти. Однако случаются ошибки, и утечки памяти являются встроенными функциями. использование ry под контролем.

bash-4.2# jcmd 16 GC.heap_info
16:
 garbage-first heap   total 5033984K, used 1969903K [0x00000006a6600000, 0x0000000800000000)
  region size 2048K, 273 young (559104K), 10 survivors (20480K)
 Metaspace       used 116770K, capacity 119844K, committed 120228K, reserved 1155072K
  class space    used 13753K, capacity 14850K, committed 14924K, reserved 1048576K
bash-4.2#

bash-4.2# #jmap -heap 16
bash-4.2# jhsdb jmap --heap --pid 16
Attaching to process ID 16, please wait...
Debugger attached successfully.
Server compiler detected.
JVM version is 11.0.1+13
using thread-local object allocation.
Garbage-First (G1) GC with 4 thread(s)
Heap Configuration:
   MinHeapFreeRatio         = 40
   MaxHeapFreeRatio         = 70
   MaxHeapSize              = 5798625280 (5530.0MB)
   NewSize                  = 1363144 (1.2999954223632812MB)
   MaxNewSize               = 3479175168 (3318.0MB)
   OldSize                  = 5452592 (5.1999969482421875MB)
   NewRatio                 = 2
   SurvivorRatio            = 8
   MetaspaceSize            = 21807104 (20.796875MB)
   CompressedClassSpaceSize = 1073741824 (1024.0MB)
   MaxMetaspaceSize         = 17592186044415 MB
   G1HeapRegionSize         = 2097152 (2.0MB)
Heap Usage:
G1 Heap:
   regions  = 2765
   capacity = 5798625280 (5530.0MB)
   used     = 144095232 (137.419921875MB)
   free     = 5654530048 (5392.580078125MB)
   2.4849895456600364% used
G1 Young Generation:
Eden Space:
   regions  = 24
   capacity = 895483904 (854.0MB)
   used     = 50331648 (48.0MB)
   free     = 845152256 (806.0MB)
   5.620608899297424% used
Survivor Space:
   regions  = 10
   capacity = 20971520 (20.0MB)
   used     = 20971520 (20.0MB)
   free     = 0 (0.0MB)
   100.0% used
G1 Old Generation:
   regions  = 36
   capacity = 4238344192 (4042.0MB)
   used     = 70694912 (67.419921875MB)
   free     = 4167649280 (3974.580078125MB)
   1.6679842126422564% used

|| echo -17 >/proc//oom_adj || сделает так, чтобы ваша JVM получила минимально возможное соотношение oomk || echo 15 >/proc//oom_adj || сделает так, чтобы ваши процессы sofice получили максимально возможное соотношение oomk. В результате, когда придет время, OOMK, скорее всего, убьет процесс soffice вместо вашего java-приложения. Меры по предотвращению Лучший способ обеспечить спокойный сон OOMK – это иметь память. Кроме того, при разработке функции можно не учитывать некоторые варианты использования или нюансы среды, которые могут привести к сбоям. JVM – исключительно хороший механизм для сохранения пулов памяти вашего MEIT, большинство из которых могут быть ограничены. использование памяти без кучи Мониторинг использования памяти кучи В некотором смысле эта часть памяти JVM не ограничена и в основном невидима. Проблема с памятью вне кучи заключается в том, что ее трудно контролировать и ограничивать. Он выделяет буфер непосредственно в памяти, минуя GC, что делает этот буфер быстрее, но чем больше и чем больше у вас буферов, тем больше вероятность того, что вы будете потреблять память, которая не будет видна в куче. Наиболее знакомым примером таких структур данных является java NIO || DirectByteBuffer, к которому даже GC не может прикоснуться. Управлять его памятью зависит только от этого собственного кода. И если специально не запрошено, эта память будет выделена за пределами кучи. Собственные библиотеки, скорее всего, будут потреблять некоторое количество памяти. собственные структуры данных. Пожалуйста, имейте в виду, что ваши зависимости от java также могут зависеть от некоторого собственного кода. Чем больше у вас собственных библиотек, тем больше свободной памяти будет потреблять ваша JVM. Они хранятся в областях памяти, не связанных с кучей. Эти вложенные приложения компилируются в .so/.dll библиотеки и загружаются в JVM. собственные библиотеки – с помощью JNI/JNA разработчики могут подключаться к написанию java-приложений, которые выполняют код C/C++. в машинном коде все значения параметров помещаются в стек, а затем вызывается функция, и каждый раз, когда вы ссылаетесь на параметр в этой функции, вы считываете его из пространства стека. Наряду с последовательностью вызовов в стеке также хранятся параметры функций. Записи стека добавляются при вызове функции и удаляются при вызове || return || или возникновении исключения. Там вы можете увидеть, какие функции вызывают какие функции, и, собственно, всю цепочку вызовов. Это очень хорошо видно в дампах потоков/трассировках стека. стеки потоков – точно так же, как в asm, C и других языках более низкого уровня, вызовы процессов/потоков складываются вместе. Чем больше у вас классов, тем больше и больше у них статических полей, тем больше памяти они будут потреблять. Поскольку классы обычно не изменяются приложениями, они хранятся в областях статической памяти. загруженные классы – загрузчики классов также загружают классы в память. Сам код JVM – JVM также является приложением, и для его работы требуется память, для запуска байт-кода java память без кучи содержит такие вещи, как Не куча – это “все остальное”. Легко, верно? Это запустит JVM и ограничит использование кучи максимум 4 ГБ. например, || java -Xmx4g -jar app.jar || Стандартный способ установить это ограничение – запустить JVM с опцией -Xmx, куча может быть жестко ограничена, чтобы никогда не превышать некоторый заранее установленный предел. Далее он разделен на несколько разделов, но мы не будем останавливаться на этом в этой статье. Куча – это место, где живут все || новые || объекты. память JVM, не относящаяся к куче, делится на: управление поиском. Пулы памяти Java/JVM используют слишком много памяти. Однако случаются ошибки, и утечки памяти являются встроенными функциями. использование ry под контролем.

echo -17 >/proc//oom_adj сделает так, чтобы ваша JVM получила минимально возможное соотношение oomk echo 15 >/proc//oom_adj сделает так, чтобы ваши процессы sofice получили максимально возможное соотношение oomk. В результате, когда придет время, OOMK, скорее всего, убьет процесс soffice вместо вашего java-приложения. Меры по предотвращению Лучший способ обеспечить спокойный сон OOMK – это иметь память. Кроме того, при разработке функции можно не учитывать некоторые варианты использования или нюансы среды, которые могут привести к сбоям. JVM – исключительно хороший механизм для сохранения пулов памяти вашего MEIT, большинство из которых могут быть ограничены. использование mory Существует способ мониторинга областей памяти вне кучи, хотя он, скорее всего, не включен по умолчанию. Мониторинг использования памяти без кучи В некотором смысле эта часть памяти JVM не ограничена и в основном невидима. Проблема с памятью вне кучи заключается в том, что ее трудно контролировать и ограничивать. Он выделяет буфер непосредственно в памяти, минуя GC, что делает этот буфер быстрее, но чем больше и чем больше у вас буферов, тем больше вероятность того, что вы будете потреблять память, которая не будет видна в куче. Наиболее знакомым примером таких структур данных является java NIO DirectByteBuffer, к которому даже GC не может прикоснуться. Управлять его памятью зависит только от этого собственного кода. И если специально не запрошено, эта память будет выделена за пределами кучи. Собственные библиотеки, скорее всего, будут потреблять некоторое количество памяти. собственные структуры данных. Пожалуйста, имейте в виду, что ваши зависимости от java также могут зависеть от некоторого собственного кода. Чем больше у вас собственных библиотек, тем больше свободной памяти будет потреблять ваша JVM. Они хранятся в областях памяти, не связанных с кучей. Эти вложенные приложения компилируются в .so/.dll библиотеки и загружаются в JVM. собственные библиотеки – с помощью JNI/JNA разработчики могут подключаться к написанию java-приложений, которые выполняют код C/C++. в машинном коде все значения параметров помещаются в стек, а затем вызывается функция, и каждый раз, когда вы ссылаетесь на параметр в этой функции, вы считываете его из пространства стека. Наряду с последовательностью вызовов в стеке также хранятся параметры функций. Записи стека добавляются при вызове функции и удаляются при вызове

16:
Native Memory Tracking:
Total: reserved=7176125KB, committed=5641761KB                                  <--- Total amount of memory NMT can account for
-                 Java Heap (reserved=5033984KB, committed=4935680KB)           <--- The heap where your objects live
                            (mmap: reserved=5033984KB, committed=4935680KB)
-                     Class (reserved=1158454KB, committed=124082KB)            <--- Class meta data
                            (classes #22594)                                    <--- Number of classes loaded
                            (  instance classes #21282, array classes #1312)
                            (malloc=3382KB #68940)
                            (mmap: reserved=1155072KB, committed=120700KB)
                            (  Metadata:   )
                            (    reserved=106496KB, committed=105904KB)
                            (    used=103839KB)
                            (    free=2065KB)
                            (    waste=0KB =0.00%)
                            (  Class space:)
                            (    reserved=1048576KB, committed=14796KB)
                            (    used=13685KB)
                            (    free=1111KB)
                            (    waste=0KB =0.00%)
-                    Thread (reserved=272638KB, committed=40430KB)              <--- Memory used by threads, including thread data structure, resource area, handle area, and so on.
                            (thread #264)
                            (stack: reserved=271344KB, committed=39136KB)       <--- Thread stack. It is marked as committed memory, but it might not be completely committed by the OS.
                            (malloc=947KB #1334)
                            (arena=347KB #527)
-                      Code (reserved=253433KB, committed=87601KB)              <--- Generated code cache (JIT)
                            (malloc=5745KB #20774)
                            (mmap: reserved=247688KB, committed=81856KB)
-                        GC (reserved=252667KB, committed=249019KB)             <--- Data use by the GC, such as card table
                            (malloc=32763KB #72438)
                            (mmap: reserved=219904KB, committed=216256KB)
-                  Compiler (reserved=3407KB, committed=3407KB)                 <--- Memory tracking used by the compiler when generating code
                            (malloc=3313KB #1836)
                            (arena=94KB #5)
-                  Internal (reserved=5884KB, committed=5884KB)                 <--- Memory that does not fit the previous categories, such as the memory used by the command line parser, JVMTI, properties, and so on.
                            (malloc=5844KB #12801)
                            (mmap: reserved=40KB, committed=40KB)
-                     Other (reserved=3810KB, committed=3810KB)                 <--- Unspecified allocations
                            (malloc=3810KB #417)
-                    Symbol (reserved=24261KB, committed=24261KB)               <--- Symbols
                            (malloc=22623KB #314562)
                            (arena=1638KB #1)
-    Native Memory Tracking (reserved=7967KB, committed=7967KB)                 <--- Memory used by NMT
                            (malloc=80KB #1113)
                            (tracking overhead=7887KB)
-        Shared class space (reserved=17172KB, committed=17172KB)               <--- Memory mapped to class data sharing archive
                            (mmap: reserved=17172KB, committed=17172KB)
-               Arena Chunk (reserved=141690KB, committed=141690KB)             <--- Allocations for the arena-managed chunk. Arena is a chunk of memory allocated using malloc
                            (malloc=141690KB)
-                   Logging (reserved=5KB, committed=5KB)                       <--- Memory used by logging
                            (malloc=5KB #190)
-                 Arguments (reserved=18KB, committed=18KB)                     <--- Amount of the native memory allocated for processing arguments
                            (malloc=18KB #494)
-                    Module (reserved=734KB, committed=734KB)                   <--- Memory used by modules
                            (malloc=734KB #4871)

|| echo -17 >/proc//oom_adj || сделает так, чтобы ваша JVM получила минимально возможное соотношение oomk || echo 15 >/proc//oom_adj || сделает так, чтобы ваши процессы sofice получили максимально возможное соотношение oomk. В результате, когда придет время, OOMK, скорее всего, убьет процесс soffice вместо вашего java-приложения. Меры по предотвращению Лучший способ обеспечить спокойный сон OOMK – это иметь память. Кроме того, при разработке функции можно не учитывать некоторые варианты использования или нюансы среды, которые могут привести к сбоям. JVM – исключительно хороший механизм для сохранения пулов памяти вашего MEIT, большинство из которых могут быть ограничены. как видите, при использовании mory NMT (встроенный трекер памяти) JVM дает вам довольно четкое представление о том, что происходит в приложении. Включение NMT приведет к снижению производительности JVM на 5-10%. Имейте в виду, что даже эти статистические данные не учитывают JNI; однако это помогает определить, сколько памяти тратится впустую JNI, что также является хорошим вкладом в сортировку! при запуске JVM с этой опцией вы можете получить доступ к статистике памяти с помощью утилиты JDK || jcmd VM.native_memory || . uNativeMemoryTracking=сводка || . -XX: Чтобы включить более глубокий мониторинг, используйте эту опцию JVM. Существует способ отслеживать области памяти вне кучи, хотя, скорее всего, он не включен по умолчанию. Мониторинг использования памяти без кучи В некотором смысле эта часть памяти JVM не ограничена и в основном невидима. Проблема с памятью вне кучи заключается в том, что ее трудно контролировать и ограничивать. Он выделяет буфер непосредственно в памяти, минуя GC, что делает этот буфер быстрее, но чем больше и чем больше у вас буферов, тем больше вероятность того, что вы будете потреблять память, которая не будет видна в куче. Наиболее знакомым примером таких структур данных является java NIO || DirectByteBuffer, к которому даже GC не может прикоснуться. Управлять его памятью зависит только от этого собственного кода. И если специально не запрошено, эта память будет выделена за пределами кучи. Собственные библиотеки, скорее всего, будут потреблять некоторое количество памяти. собственные структуры данных. Пожалуйста, имейте в виду, что ваши зависимости от java также могут зависеть от некоторого собственного кода. Чем больше у вас собственных библиотек, тем больше свободной памяти будет потреблять ваша JVM. Они хранятся в областях памяти, не связанных с кучей. Эти вложенные приложения компилируются в .so/.dll библиотеки и загружаются в JVM. собственные библиотеки – с помощью JNI/JNA разработчики могут подключаться к написанию java-приложений, которые выполняют код C/C++. в машинном коде все значения параметров помещаются в стек, а затем вызывается функция, и каждый раз, когда вы ссылаетесь на параметр в этой функции, вы считываете его из пространства стека. Наряду с последовательностью вызовов в стеке также хранятся параметры функций. Записи стека добавляются при вызове функции и удаляются при вызове || return || или возникновении исключения. Там вы можете увидеть, какие функции вызывают какие функции, и, собственно, всю цепочку вызовов. Это очень хорошо видно в дампах потоков/трассировках стека. стеки потоков – точно так же, как в asm, C и других языках более низкого уровня, вызовы процессов/потоков складываются вместе. Чем больше у вас классов, тем больше и больше у них статических полей, тем больше памяти они будут потреблять. Поскольку классы обычно не изменяются приложениями, они хранятся в областях статической памяти. загруженные классы – загрузчики классов также загружают классы в память. Сам код JVM – JVM также является приложением, и для его работы требуется память, для запуска байт-кода java память без кучи содержит такие вещи, как Не куча – это “все остальное”. Легко, верно? Это запустит JVM и ограничит использование кучи максимум 4 ГБ. например, || java -Xmx4g -jar app.jar || Стандартный способ установить это ограничение – запустить JVM с опцией -Xmx, куча может быть жестко ограничена, чтобы никогда не превышать некоторый заранее установленный предел. Далее он разделен на несколько разделов, но мы не будем останавливаться на этом в этой статье. Куча – это место, где живут все || новые || объекты. память JVM, не относящаяся к куче, делится на: управление поиском. Пулы памяти Java/JVM используют слишком много памяти. Однако случаются ошибки, и утечки памяти являются встроенными функциями. использование ry под контролем. || echo -17 >/proc//oom_adj || сделает так, чтобы ваша JVM получила минимально возможное соотношение oomk || echo 15 >/proc//oom_adj || сделает так, чтобы ваши процессы sofice получили максимально возможное соотношение oomk. В результате, когда придет время, OOMK, скорее всего, убьет процесс soffice вместо вашего java-приложения. Меры по предотвращению Лучший способ обеспечить спокойный сон OOMK – это иметь память. Кроме того, при разработке функции можно не учитывать некоторые варианты использования или нюансы среды, которые могут привести к сбоям. JVM – исключительно хороший механизм для сохранения пулов памяти вашего MEIT, большинство из которых могут быть ограничены. общее использование некоторых из этих арен может быть ограничено, другие – как бы ограничены, в то время как другие теоретически могут расти до тех пор, пока на сервере/контейнере есть свободная оперативная память (или достигнуты ограничения ОС). Как вы видите, NMT JVM (собственный трекер памяти) дает вам довольно четкое представление о том, что происходит в приложении. Включение NMT приведет к снижению производительности JVM на 5-10%. Имейте в виду, что даже эти статистические данные не учитывают JNI; однако это помогает определить, сколько памяти тратится JNI впустую, что также является хорошим вкладом в сортировку! при запуске JVM с этой опцией вы можете получить доступ к статистике памяти с помощью утилиты JDK || jcmd VM.native_memory || . uNativeMemoryTracking=краткое описание || . -XX: Чтобы включить более углубленный мониторинг, используйте эту опцию JVM. Есть способ отслеживать области памяти вне кучи, хотя, скорее всего, он не включен по умолчанию. Мониторинг использования памяти без кучи В некотором смысле эта часть памяти JVM не ограничена и в основном невидима. Проблема с памятью вне кучи заключается в том, что ее трудно контролировать и ограничивать. Он выделяет буфер непосредственно в памяти, минуя GC, что делает этот буфер быстрее, но чем больше и чем больше у вас буферов, тем больше вероятность того, что вы будете потреблять память, которая не будет видна в куче. Наиболее знакомым примером таких структур данных является java NIO || DirectByteBuffer, к которому даже GC не может прикоснуться. Управлять его памятью зависит только от этого собственного кода. И если специально не запрошено, эта память будет выделена за пределами кучи. Собственные библиотеки, скорее всего, будут потреблять некоторое количество памяти. собственные структуры данных. Пожалуйста, имейте в виду, что ваши зависимости от java также могут зависеть от некоторого собственного кода. Чем больше у вас собственных библиотек, тем больше свободной памяти будет потреблять ваша JVM. Они хранятся в областях памяти, не связанных с кучей. Эти вложенные приложения компилируются в .so/.dll библиотеки и загружаются в JVM. собственные библиотеки – с помощью JNI/JNA разработчики могут подключаться к написанию java-приложений, которые выполняют код C/C++. в машинном коде все значения параметров помещаются в стек, а затем вызывается функция, и каждый раз, когда вы ссылаетесь на параметр в этой функции, вы считываете его из пространства стека. Наряду с последовательностью вызовов в стеке также хранятся параметры функций. Записи стека добавляются при вызове функции и удаляются при вызове || return || или возникновении исключения. Там вы можете увидеть, какие функции вызывают какие функции, и, собственно, всю цепочку вызовов. Это очень хорошо видно в дампах потоков/трассировках стека. стеки потоков – точно так же, как в asm, C и других языках более низкого уровня, вызовы процессов/потоков складываются вместе. Чем больше у вас классов, тем больше и больше у них статических полей, тем больше памяти они будут потреблять. Поскольку классы обычно не изменяются приложениями, они хранятся в областях статической памяти. загруженные классы – загрузчики классов также загружают классы в память. Сам код JVM – JVM также является приложением, и для его работы требуется память, для запуска байт-кода java память без кучи содержит такие вещи, как Не куча – это “все остальное”. Легко, верно? Это запустит JVM и ограничит использование кучи максимум 4 ГБ. например, || java -Xmx4g -jar app.jar || Стандартный способ установить это ограничение – запустить JVM с опцией -Xmx, куча может быть жестко ограничена, чтобы никогда не превышать некоторый заранее установленный предел. Далее он разделен на несколько разделов, но мы не будем останавливаться на этом в этой статье. Куча – это место, где живут все || новые || объекты. память JVM, не относящаяся к куче, делится на: управление поиском. Пулы памяти Java/JVM используют слишком много памяти. Однако случаются ошибки, и утечки памяти являются встроенными функциями. использование ry под контролем.

- echo -17 >/proc//oom_adj
- сделает так, чтобы ваша JVM получила минимально возможное соотношение oomk
- echo 15 >/proc//oom_adj
- сделает так, чтобы ваши процессы sofice получили максимально возможное соотношение oomk. В результате, когда придет время, OOMK, скорее всего, убьет процесс soffice вместо вашего java-приложения. Меры по предотвращению Лучший способ обеспечить спокойный сон OOMK – это иметь память. Кроме того, при разработке функции можно не учитывать некоторые варианты использования или нюансы среды, которые могут привести к сбоям. JVM – исключительно хороший механизм для сохранения пулов памяти вашего MEIT, большинство из которых могут быть ограничены. скорость использования mory: Вы можете ограничить: некоторые из этих арен могут быть ограничены, другие – как бы ограничены, в то время как другие теоретически могут расти до тех пор, пока на сервере/контейнере есть свободная оперативная память (или достигнуты ограничения ОС). Как вы видите, NMT JVM (собственный трекер памяти) дает вам довольно четкое представление о том, что происходит в приложении. Включение NMT приведет к снижению производительности JVM на 5-10%. Имейте в виду, что даже эти статистические данные не учитывают JNI; однако это помогает определить, сколько памяти тратится JNI впустую, что также является хорошим вкладом в сортировку! при запуске JVM с этой опцией вы можете получить доступ к статистике памяти с помощью утилиты JDK
- jcmd VM.native_memory
. uNativeMemoryTracking=краткое описание
- . -XX: Чтобы включить более углубленный мониторинг, используйте эту опцию JVM. Есть способ отслеживать области памяти вне кучи, хотя, скорее всего, он не включен по умолчанию. Мониторинг использования памяти без кучи В некотором смысле эта часть памяти JVM не ограничена и в основном невидима. Проблема с памятью вне кучи заключается в том, что ее трудно контролировать и ограничивать. Он выделяет буфер непосредственно в памяти, минуя GC, что делает этот буфер быстрее, но чем больше и чем больше у вас буферов, тем больше вероятность того, что вы будете потреблять память, которая не будет видна в куче. Наиболее знакомым примером таких структур данных является java NIO
- DirectByteBuffer, к которому даже GC не может прикоснуться. Управлять его памятью зависит только от этого собственного кода. И если специально не запрошено, эта память будет выделена за пределами кучи. Собственные библиотеки, скорее всего, будут потреблять некоторое количество памяти. собственные структуры данных. Пожалуйста, имейте в виду, что ваши зависимости от java также могут зависеть от некоторого собственного кода. Чем больше у вас собственных библиотек, тем больше свободной памяти будет потреблять ваша JVM. Они хранятся в областях памяти, не связанных с кучей. Эти вложенные приложения компилируются в .so/.dll библиотеки и загружаются в JVM. собственные библиотеки – с помощью JNI/JNA разработчики могут подключаться к написанию java-приложений, которые выполняют код C/C++. в машинном коде все значения параметров помещаются в стек, а затем вызывается функция, и каждый раз, когда вы ссылаетесь на параметр в этой функции, вы считываете его из пространства стека. Наряду с последовательностью вызовов в стеке также хранятся параметры функций. Записи стека добавляются при вызове функции и удаляются при вызове
return
- или возникновении исключения. Там вы можете увидеть, какие функции вызывают какие функции, и, собственно, всю цепочку вызовов. Это очень хорошо видно в дампах потоков/трассировках стека. стеки потоков – точно так же, как в asm, C и других языках более низкого уровня, вызовы процессов/потоков складываются вместе. Чем больше у вас классов, тем больше и больше у них статических полей, тем больше памяти они будут потреблять. Поскольку классы обычно не изменяются приложениями, они хранятся в областях статической памяти. загруженные классы – загрузчики классов также загружают классы в память. Сам код JVM – JVM также является приложением, и для его работы требуется память, для запуска байт-кода java память без кучи содержит такие вещи, как Не куча – это “все остальное”. Легко, верно? Это запустит JVM и ограничит использование кучи максимум 4 ГБ. например,

|| echo -17 >/proc//oom_adj || сделает так, чтобы ваша JVM получила минимально возможное соотношение oomk || echo 15 >/proc//oom_adj || сделает так, чтобы ваши процессы sofice получили максимально возможное соотношение oomk. В результате, когда придет время, OOMK, скорее всего, убьет процесс soffice вместо вашего java-приложения. Меры по предотвращению Лучший способ обеспечить спокойный сон OOMK – это иметь память. Кроме того, при разработке функции можно не учитывать некоторые варианты использования или нюансы среды, которые могут привести к сбоям. JVM – исключительно хороший механизм для сохранения пулов памяти вашего MEIT, большинство из которых могут быть ограничены. общее использование, к сожалению, нет возможности ограничить другие области или блоки памяти, выделенные JNI. Хотя вы можете ограничить область стека одного потока, если JVM увеличит количество потоков, потребление памяти все равно может резко возрасти. Однако нет способа ограничить количество потоков, которые может создавать JVM. -Подразделение Xss10m также может ограничивать потоки, ограничивая их максимальные размеры стека с помощью W-XX:ReservedCodeCacheSize = Кэш кода JIT -XX:MaxMetaspaceSize =N -XX:MaxPermSize = Классы: -XX:MaxRAM = N -XX:Maxramfraction =N (до java10) (чтобы заставить JVM поверить, что ВСЯ оперативная память – это то, что говорят группы, а не ОС) -XX:+Поддержка USECONTAINERS -XX:Maxrampercentage=N (используйте с Поддержка использования контейнеров в контейнерах) N (если установлено, отключает нижеприведенные механизмы) -Xmx = N/-Xms = Куча: Вы можете ограничить: Некоторые из этих арен могут быть ограничены, другие – вроде как ограничены, в то время как другие теоретически могут расти до тех пор, пока на сервере/контейнере есть свободная оперативная память (или достигнуты ограничения ОС). Как вы видите, NMT JVM (собственный трекер памяти) дает вам довольно четкое представление о том, что происходит в приложении. Включение NMT приведет к снижению производительности JVM на 5-10%. Имейте в виду, что даже эти статистические данные не учитывают JNI; однако это помогает определить, сколько памяти тратится JNI впустую, что также является хорошим вкладом в сортировку! при запуске JVM с этой опцией вы можете получить доступ к статистике памяти с помощью утилиты JDK || jcmd VM.native_memory || . uNativeMemoryTracking=сводка || . -XX: Чтобы включить более глубокий мониторинг, используйте эту опцию JVM. Существует способ отслеживать области памяти вне кучи, хотя, скорее всего, он не включен по умолчанию. Мониторинг использования памяти без кучи В некотором смысле эта часть памяти JVM не ограничена и в основном невидима. Проблема с памятью вне кучи заключается в том, что ее трудно контролировать и ограничивать. Он выделяет буфер непосредственно в памяти, минуя GC, что делает этот буфер быстрее, но чем больше и чем больше у вас буферов, тем больше вероятность того, что вы будете потреблять память, которая не будет видна в куче. Наиболее знакомым примером таких структур данных является java NIO || DirectByteBuffer, к которому даже GC не может прикоснуться. Управлять его памятью зависит только от этого собственного кода. И если специально не запрошено, эта память будет выделена за пределами кучи. Собственные библиотеки, скорее всего, будут потреблять некоторое количество памяти. собственные структуры данных. Пожалуйста, имейте в виду, что ваши зависимости от java также могут зависеть от некоторого собственного кода. Чем больше у вас собственных библиотек, тем больше свободной памяти будет потреблять ваша JVM. Они хранятся в областях памяти, не связанных с кучей. Эти вложенные приложения компилируются в .so/.dll библиотеки и загружаются в JVM. собственные библиотеки – с помощью JNI/JNA разработчики могут подключаться к написанию java-приложений, которые выполняют код C/C++. в машинном коде все значения параметров помещаются в стек, а затем вызывается функция, и каждый раз, когда вы ссылаетесь на параметр в этой функции, вы считываете его из пространства стека. Наряду с последовательностью вызовов в стеке также хранятся параметры функций. Записи стека добавляются при вызове функции и удаляются при вызове || return || или возникновении исключения. Там вы можете увидеть, какие функции вызывают какие функции, и, собственно, всю цепочку вызовов. Это очень хорошо видно в дампах потоков/трассировках стека. стеки потоков – точно так же, как в asm, C и других языках более низкого уровня, вызовы процессов/потоков складываются вместе. Чем больше у вас классов, тем больше и больше у них статических полей, тем больше памяти они будут потреблять. Поскольку классы обычно не изменяются приложениями, они хранятся в областях статической памяти. загруженные классы – загрузчики классов также загружают классы в память. Сам код JVM – JVM также является приложением, и для его работы требуется память, для запуска байт-кода java память без кучи содержит такие вещи, как Не куча – это “все остальное”. Легко, верно? Это запустит JVM и ограничит использование кучи максимум 4 ГБ. например, || java -Xmx4g -jar app.jar || Стандартный способ установить это ограничение – запустить JVM с опцией -Xmx, куча может быть жестко ограничена, чтобы никогда не превышать некоторый заранее установленный предел. Далее он разделен на несколько разделов, но мы не будем останавливаться на этом в этой статье. Куча – это место, где живут все || новые || объекты. память JVM, не относящаяся к куче, делится на: управление поиском. Пулы памяти Java/JVM используют слишком много памяти. Однако случаются ошибки, и утечки памяти являются встроенными функциями. использование ry под контролем.

echo -17 >/proc//oom_adj сделает так, чтобы ваша JVM получила минимально возможное соотношение oomk echo 15 >/proc//oom_adj