что делает данная программа когда ее запускают с помощью строки java mystery mighty mouse
Зона кода
Эту статью я написал несколько лет назад для другого сайта, но она так и не была опубликована. Тогда 7-я версия Java только-только появилась на свет, а 6-я была всё ещё актуальна. Статья адресована, в первую очередь тем, кто начинает знакомиться с языком Java. Я решил стряхнуть с неё пыль и опубликовать: пусть будет!
Здравствуйте, уважаемый читатель! Эта статья состоит из двух частей.
Первая из них адресована новичкам, которые только-только приступают к изучению Java и, возможно, не написали ещё ни одной программы на этом языке.
Новичкам
Метод main() должен объявляться в классе следующим образом:
Ключевое слово public означает, что метод main() доступен везде, где доступен содержащий его класс. Ключевое слово static означает, что метод является статическим, т. е. не требует для своего вызова наличие экземпляра класса. Ключевое слово void означает, что метод не возвращает никакого значения. Все эти три слова обязательно должны присутствовать в описании метода.
Вместо имени массива args можно использовать любое другое имя. Например, следующее описание main() вполне корректно.
Сохраним код класса MainTest в файле с именем MainTest.java и скомпилируем этот файл командой
java MainTest Это всего лишь проверка!
Если нет проблем с отображением кириллицы, то в результате выполнения команды на консоль будет выведено:
Это
всего
лишь
проверка!
Метод main() может вызываться не только виртуальной машиной Java, но и любым другим методом. Например, main() может быть рекурсивным, т. е. может вызывать сам себя. В этом отношении main() ничем не отличается от остальных методов.
В следующем примере (весьма вычурном) метод main() рекурсивен. При каждом вызове метода, за исключением последнего, на печать выводится один аргумент командной строки.
Новичкам и не только
В Интернете на форумах, посвящённых Java, я нередко встречал любопытную задачку: написать класс, метод main() которого имеет пустое тело, выводящий на консоль надпись “Hello world!”. Полагаю, что эта задача известна многим из тех, кто интересуется Java.
Статический блок имеет некоторое сходство со статическим методом. Отличается он от последнего тем, что не имеет имени, не принимает параметров, не возвращает значения (а значит, не может содержать инструкции return ) и не вызывается явно. Так же как и статический метод, статический блок может содержать обращения к статическим полям и методам класса.
Статические блоки используются редко. Как правило, в их задачи входит инициализация статических полей класса.
Ну а мы поместим в статический блок инструкцию вывода на консоль строки “Hello world!”:
Можно скомпилировать класс, запустить на выполнение и удостовериться в том, что с поставленной задачей он вполне успешно справляется.
На консоль будет выведено:
Привет от static-блока!
Привет от метода main()!
Вот код, демонстрирующий данный подход:
И вот тут начинается самое интересное! Я компилировал и запускал этот класс с использованием комплектов разработки на языке Java (JDK) трёх разных версий: jdk1.6_021, jdk1.6_024 и jdk1.7.0_01. Во всех трёх случаях код компилировался без проблем. А вот с запуском класса проблемы возникали.
Для начала, оговорюсь, что каждый файл с расширением class запускался под управлением “своей” виртуальной машины Java, т. е. входящей в тот JDK, посредством которого этот файл был получен в результате компиляции.
Итак, в последних двух случаях на экран выводилась надпись:
Error: Main method not found in class WithoutMain, please define the main method as: public static void main(String[] args)
Таким образом, не выполнялся даже код, входящий в статический блок. А вот в первом случае на консоль выводилось следующее:
HelloWorld!
Exception in thread «main» java.lang.NoSuchMethodError: main
Выполнение программы приводит к следующему выводу на консоль:
Запустите приложение Java из командной строки
Узнайте, как создать и запустить приложение JAR с аргументами командной строки или без них
1. Обзор
Как правило, каждое значимое приложение включает в себя один или несколько файлов JAR в качестве зависимостей. Однако бывают случаи, когда сам файл JAR представляет собой автономное приложение или веб-приложение.
В этой статье мы сосредоточимся на сценарии автономного приложения. В дальнейшем мы будем называть его приложением JAR.
В этом уроке мы сначала узнаем, как создать приложение JAR. Позже мы узнаем, как запускать приложение JAR с аргументами командной строки или без них|/.
2. Создайте приложение JAR
Прежде всего, давайте рассмотрим краткий пример того, как скомпилировать наши классы и создать исполняемый файл JAR с файлом манифеста:
Вот как мы создадим неисполняемую банку без файла манифеста:
3. Аргументы командной строки Java
Как и любое приложение, приложение JAR принимает любое количество аргументов, включая нулевые аргументы. Все зависит от потребностей приложения.
В результате приложение может избежать жестко закодированных значений и по-прежнему может обрабатывать множество различных вариантов использования.
Аргумент может содержать любые буквенно-цифровые символы, символы юникода и, возможно, некоторые специальные символы, разрешенные оболочкой, например”@”.
Обычно для типичного приложения Java при вызове приложения пользователь вводит аргументы командной строки после имени класса.
Однако это не всегда относится к приложениям JAR.
4. Запустите исполняемый файл JAR с аргументами
Давайте рассмотрим базовый синтаксис для запуска исполняемого файла JAR с аргументами:
Исполняемый файл JAR, созданный ранее, представляет собой простое приложение, которое просто выводит переданные аргументы. Мы можем запустить его с любым количеством аргументов. Ниже приведен пример с двумя аргументами:
Мы увидим следующий вывод в консоли:
Следовательно, другие приложения в том же исполняемом файле JAR не могут быть установлены в файле манифеста, но мы все равно можем запускать их из командной строки, как и для неисполняемого файла JAR. Как именно, мы увидим в следующем разделе.
5. Запустите неисполняемую банку с аргументами
Неисполняемый JAR, созданный ранее, содержит то же самое простое приложение. Мы можем бежать
Неисполняемый JAR, созданный ранее, содержит то же самое простое приложение. Мы можем бежать
Неисполняемый JAR, созданный ранее, содержит то же самое простое приложение. Мы можем бежать
В этом уроке мы изучили два способа запуска приложения JAR в командной строке с аргументами или без них.
Мы также продемонстрировали, что аргумент может содержать пробелы и специальные символы (если это разрешено оболочкой).
Выполнение команд оболочки с помощью Java
В этом уроке мы рассмотрим, как выполнять команды оболочки, файлы bat и sh на Java. Мы рассмотрим примеры для всех подходов exec() и ProcessBuilder.
Вступление
В этой статье мы рассмотрим, как мы можем использовать классы Runtime и ProcessBuilder для выполнения команд и сценариев оболочки с помощью Java.
Мы используем компьютеры для автоматизации многих вещей в нашей повседневной работе. Системные администраторы постоянно выполняют множество команд, некоторые из которых очень повторяющиеся и требуют минимальных изменений в промежутках между запусками.
Этот процесс также созрел для автоматизации. Нет необходимости запускать все вручную. Используя Java, мы можем запускать одну или несколько команд оболочки, выполнять сценарии оболочки, запускать терминал/командную строку, устанавливать рабочие каталоги и управлять переменными среды с помощью основных классов.
Время выполнения.exec()
Класс Runtime в Java-это класс высокого уровня, присутствующий в каждом отдельном приложении Java. Через него само приложение взаимодействует с окружающей средой, в которой оно находится.
Метод exec() предлагает несколько перегруженных вариантов:
Стоит отметить, что эти процессы запускаются извне из интерпретатора и будут зависеть от системы.
Вам решать, хотите ли вы использовать exec(«директория/папка») или exec(новая строка[] <"директория", "/папка">.
Давайте приведем несколько примеров, чтобы увидеть, чем эти перегруженные методы отличаются друг от друга.
Выполнение команды из строки
Давайте начнем с самого простого подхода из этих трех:
Запуск этого кода приведет к выполнению команды, которую мы предоставили в строковом формате. Однако мы ничего не видим, когда запускаем это.
Укажите рабочий каталог
Если вы хотите запустить команду, скажем, из определенной папки, мы бы сделали что-то вроде:
Запуск предыдущего фрагмента кода приведет к:
Давайте посмотрим, как мы могли бы предоставить предыдущую команду в нескольких отдельных частях, а не в одной строке:
Запуск этого фрагмента кода также приведет к:
В конечном счете, независимо от подхода – с использованием одной строки или массива строк, вводимая вами команда всегда будет разбита на массив перед обработкой базовой логикой.
Какой из них вы хотели бы использовать, сводится только к тому, какой из них вы считаете более читабельным.
Использование Переменных Среды
Давайте посмотрим, как мы можем использовать переменные среды:
Выполнение этого кода вернет:
Иногда просто гораздо проще выгрузить все в файл и запустить этот файл вместо того, чтобы добавлять все программно.
Git Essentials
Ознакомьтесь с этим практическим руководством по изучению Git, содержащим лучшие практики и принятые в отрасли стандарты. Прекратите гуглить команды Git и на самом деле изучите это!
Тогда давайте воспользуемся тем же подходом, что и раньше:
Запуск этого кода, несомненно, приведет к:
Теперь, когда все перегруженные exec() подписи устранены, давайте рассмотрим класс ProcessBuilder и то, как мы можем выполнять команды с его помощью.
Конструктор процессов
ProcessBuilder является базовым механизмом, который выполняет команды при использовании метода Runtime.getRuntime().exec() :
JavaDocs для Время выполнения класс
Взглянув на то, как ProcessBuilder принимает наши входные данные из метода exec() и запускает команду, мы также получаем хорошее представление о том, как ее использовать.
Давайте рассмотрим эти варианты.
ProcessBuilder: Выполнение команды из строк
Запуск этого кода приведет к:
ProcessBuilder: Укажите рабочий каталог
Вместо того, чтобы указывать рабочий каталог с помощью команды, давайте установим его программно:
Здесь мы установили рабочий каталог таким же, как и раньше, но мы удалили это определение из самой команды. Выполнение этого кода даст тот же результат, что и в предыдущем примере.
ProcessBuilder: Переменные среды
Давайте получим переменные среды, доступные в настоящее время, а затем добавим некоторые для последующего использования:
Здесь мы упаковали возвращенные переменные среды в Map и запустили forEach() на нем, чтобы распечатать значения на нашей консоли.
Выполнение этого кода приведет к получению списка переменных среды, имеющихся на вашем компьютере:
Теперь давайте добавим переменную среды в этот список и будем использовать ее:
Запуск этого кода приведет к:
Конечно, как только программа завершит работу, эта переменная не останется в списке.
Если вы хотите снова запустить файл, мы просто предоставим экземпляру ProcessBuilder необходимую информацию:
Вывод
Используя Java, мы можем запускать одну или несколько команд оболочки, выполнять сценарии оболочки, запускать терминал/командную строку, устанавливать рабочие каталоги и управлять переменными среды с помощью основных классов.
Как собрать простейшую Java программу с помощью Maven
Статья написана для тех, кто умеет писать простейшие программы на java, но не умеет их собирать. Этим людям уже известно, что такое классы, что такое пакеты и зачем нужен public static main(String[] argv), но код без среды разработки они не запускали, да и не понимают кому и зачем это вообще может понадобиться.
Сразу скажу, что Java программиста, который не может собрать свою программу из консольки, на работу не возьмут, и это в общем более чем достаточная причина, чтобы научиться искусству обращения с системами сборки. Остальное детали, которым и посвящена статья.
Я принципиально не буду обсуждать в статье ничего, кроме сборки минимального HelloWorld. Также я постараюсь опустить все технические детали, которые можно опустить и подробно раскрыть всё, без понимания чего обойтись нельзя.
Для того, чтобы воспользоваться информацией из статьи нужно знать, что такое xml, переменные окружения, зачем нужна переменная окружения PATH и как пользоваться консолью.
Зачем собирать код без IDE
Первый вопрос, который возникает у начинающего разработчика — как в реальной жизни может пригодиться умение собирать код без среды разработки. Она ведь установлена и настроена у всех — это первое, что делает программист, когда приходит на проект.
Ответ простой — для того, чтобы нормально организовать рабочий процесс — код нужно регулярно собирать, проверять что он вообще компилируется, а потом, для того чтобы убедиться в работоспособности кода, прогонять тесты.
Можно, конечно, выделить специального человека, который будет раз в 15 минут запускать IDE и проводить описанные выше процедуры, но это безумие, такие вещи следует делать автоматически.
Уметь собирать код без среды разработки — суровая необходимость. Настолько суровая, что для решения этой задачи существует особый класс программного обеспечения, называемого системами сборки.
Что такое система сборки?
Система сборки это программа, которая собирает другие программы. На вход система сборки получает исходный код, а на выход выдаёт программу, которую уже можно запустить.
Чем она отличается от компилятора? Если коротко, то система сборки вызывает компилятор при своей работе, а компилятор о существовании системы сборки даже не подозревает.
Если более длинно, то сборка, помимо компиляции, включает в себя ещё целый спектр задач, для решения которых компилятор не пригоден от слова совсем.
Например, если программе для работы нужны какие-нибудь картинки, то положить их в директорию с программой — задача системы сборки. Если программе нужны сторонние библиотеки, то положить их в директорию с программой — задача системы сборки. Ну и так далее.
И да, если автоматическая сборка проекта настроена и работает, то нет нужды вручную конфигурировать IDE — современная среда разработки сгенерирует проект самостоятельно, достаточно показать ей где находится конфигурация для системы сборки.
Систем сборки для java по большому счёту 3 — ant, maven и gradle. ant отживает свой век, нынче его используют либо ретрограды, либо реально крутые чуваки, типа Антона Кекса, gradle пока удел хипстеров, а вот maven — стандарт индустрии. Уметь им пользоваться просто необходимо.
Как установить maven
Maven устанавливается просто копированием в нужную директорию — никакого инсталлера нет. Как и в случае с большинством консольных утилит для использования достаточно добавить директорию maven/bin в переменную окружения PATH.
То есть, если maven находится в d:/soft/maven, то в PATH надо добавить d:/soft/maven/bin
Ещё для работы maven потребует переменную JAVA_HOME, которая указывает на JDK. Если JDK находится в C:/Program Files/Java/jdk1.8.0_05, то именно такое значение нужно поместить в JAVA_HOME. Добавлять bin в конец не нужно.
После этого можно попробовать написать в консоли
Если получится, значит maven установлен.
Как структурировать проект для maven
В терминологии maven совокупность файлов с исходным кодом программы, файлов настроек и всего такого называется проектом. Директория, в которой располагаются эти файлы, называется корневой директорией проекта. В дальшейшем я буду обозначать эту директорию как
Как известно, язык программирования java навязывает программисту структуру директорий, которая диктует расположение файлов с классами. Напимер класс с полным именем com.app.HelloWorld должен находиться в файле com/app/HelloWorld.java и никак иначе.
Maven добавляет к этому ограничению ещё одно — исходный код должен находиться в директории
/src/main/java. То есть класс com.app.HelloWorld maven будет искать в
Вот как будет выглядеть этот самый HelloWorld
Как сделать описание проекта
Содержимое минимального файла pom.xml будет примерно следующим. Для прохождения туториала можно таким его и оставить, если ничего не поменять, код нормально соберётся.
Что тут было существенно важного и что надо запомнить? Запомнить надо вот эти три строки.
Эти три строки являются идентификатором программы для внешнего мира. Программа, она же результат работы по сборке проекта, в терминологии maven называется артефактом.
Непонятное слово артефакт используется здесь вместо понятного слова программа потому, что результатом работы системы сборки может быть не только собственно программа, но и библиотека или ещё что-нибудь эдакое. Комбинация параметров groupId, artifactId и version уникальна для каждого артефакта. Об уникальности этой комбинации должен позаботиться программист.
Технически, значения этих параметров могут быть любыми, но при их выборе строго рекомендуется соблюдать правила хорошего тона.
groupId
В groupId обычно находится название какого-нибудь пакета. Напомню, что название пакета согласно тем же правилам хорошего тона, должно быть именем веб-домена, владельцем которого является автор пакета, что позволяет худо-бедно обеспечить уникальность названия.
artifactId
В artifactId — строка с именем артефакта, которое придумывает его создатель. Как правило это какое-нибудь слово, иногда с разделителями в виде тире. Например hibernate-annotation-wat. artifactId должны быть уникальны в рамках groupId.
version
Ну и наконец version это версия артефакта, которую надо увеличивать при каждом более-менее значительном изменении. Версия обычно включает цифрры и буквы. Типа 1.0-SNAPSHOT
Как собрать проект
Теперь, когда структура файлов проекта соответствует ожидаемой, а его описание присутствует в файле pom.xml, для того, чтобы собрать проект, осталось только открыть консоль, сменить текущую директорию на директорию проекта и написать в консоли:
После того, как maven закончит свою работу, в директории проекта появится директория target, в которой будет находиться скомпилированный код.
Скомпилированный java код выглядит так же, как исходный, только вместо файлов с расширением java в директориях, соответствующих названиями пакетов, находятся файлы с расширением class, в которых будет уже не исходный код, а код, предназначенный для интерпретации джава-машиной.
То есть теперь этот код можно запустить.
Как запустить проект
Чтобы запустить скомпилированный код, нужно в консоли из этой же директории набрать
После того, как maven перестанет качать всякую дрянь из интернета, где-то перед здоровой табличкой с надписью BUILD SUCCESS, появится строчка Hello World.
Код отработал, всё прошло удачно.
Вот так собирают java программы с помощью системы сборки maven.
Итого
maven ищет код для сборки в директории
Инструкции по сборке maven будет искать в
Результат работы системы сборки называется артефактом.
От программиста требуется задать groupId, artifactId и version
Сборка осуществляется командой mvn compile
Скомпилированный java код выглядит так же, как исходный код, но вместо файлов с расширением java, там будут файлы с расширением class.
Управление памятью Java
Это глубокое погружение в управление памятью Java позволит расширить ваши знания о том, как работает куча, ссылочные типы и сборка мусора.
Вероятно, вы могли подумать, что если вы программируете на Java, то вам незачем знать о том, как работает память. В Java есть автоматическое управление памятью, красивый и тихий сборщик мусора, который работает в фоновом режиме для очистки неиспользуемых объектов и освобождения некоторой памяти.
Поэтому вам, как программисту на Java, не нужно беспокоиться о таких проблемах, как уничтожение объектов, поскольку они больше не используются. Однако, даже если в Java этот процесс выполняется автоматически, он ничего не гарантирует. Не зная, как устроен сборщик мусора и память Java, вы можете создать объекты, которые не подходят для сбора мусора, даже если вы их больше не используете.
Для начала давайте посмотрим, как обычно организована память в Java:
Структура памяти
Стек (Stack)
Стековая память отвечает за хранение ссылок на объекты кучи и за хранение типов значений (также известных в Java как примитивные типы), которые содержат само значение, а не ссылку на объект из кучи.
Кроме того, переменные в стеке имеют определенную видимость, также называемую областью видимости. Используются только объекты из активной области. Например, предполагая, что у нас нет никаких глобальных переменных (полей) области видимости, а только локальные переменные, если компилятор выполняет тело метода, он может получить доступ только к объектам из стека, которые находятся внутри тела метода. Он не может получить доступ к другим локальным переменным, так как они не выходят в область видимости. Когда метод завершается и возвращается, верхняя часть стека выталкивается, и активная область видимости изменяется.
Возможно, вы заметили, что на картинке выше отображено несколько стеков памяти. Это связано с тем, что стековая память в Java выделяется для каждого потока. Следовательно, каждый раз, когда поток создается и запускается, он имеет свою собственную стековую память и не может получить доступ к стековой памяти другого потока.
Куча (Heap)
Эта часть памяти хранит в памяти фактические объекты, на которые ссылаются переменные из стека. Например, давайте проанализируем, что происходит в следующей строке кода:
Ключевое слово new несет ответственность за обеспечение того, достаточно ли свободного места на куче, создавая объект типа StringBuilder в памяти и обращаясь к нему через «Builder» ссылки, которая попадает в стек.
Для каждого запущенного процесса JVM существует только одна область памяти в куче. Следовательно, это общая часть памяти независимо от того, сколько потоков выполняется. На самом деле структура кучи немного отличается от того, что показано на картинке выше. Сама куча разделена на несколько частей, что облегчает процесс сборки мусора.
Типы ссылок
Если вы внимательно посмотрите на изображение структуры памяти, вы, вероятно, заметите, что стрелки, представляющие ссылки на объекты из кучи, на самом деле относятся к разным типам. Это потому, что в языке программирования Java используются разные типы ссылок: сильные, слабые, мягкие и фантомные ссылки. Разница между типами ссылок заключается в том, что объекты в куче, на которые они ссылаются, имеют право на сборку мусора по различным критериям. Рассмотрим подробнее каждую из них.
1. Сильная ссылка
Это самые популярные ссылочные типы, к которым мы все привыкли. В приведенном выше примере со StringBuilder мы фактически храним сильную ссылку на объект из кучи. Объект в куче не удаляется сборщиком мусора, пока на него указывает сильная ссылка или если он явно доступен через цепочку сильных ссылок.
2. Слабая ссылка
Попросту говоря, слабая ссылка на объект из кучи, скорее всего, не сохранится после следующего процесса сборки мусора. Слабая ссылка создается следующим образом:
После сбора мусора ключа из WeakHashMap вся запись удаляется из карты.
3. Мягкая ссылка
Подобно слабым ссылкам, мягкая ссылка создается следующим образом:
4. Фантомная ссылка
Ссылки на String
Ссылки на тип String в Java обрабатываются немного по- другому. Строки неизменяемы, что означает, что каждый раз, когда вы делаете что-то со строкой, в куче фактически создается другой объект. Для строк Java управляет пулом строк в памяти. Это означает, что Java сохраняет и повторно использует строки, когда это возможно. В основном это верно для строковых литералов. Например:
При запуске этот код распечатывает следующее:
Следовательно, оказывается, что две ссылки типа String на одинаковые строковые литералы фактически указывают на одни и те же объекты в куче. Однако это не действует для вычисляемых строк. Предположим, что у нас есть следующее изменение в строке // 1 приведенного выше кода.
Strings are different
При добавлении вышеуказанного изменения создается следующий результат:
Процесс сборки мусора
Как обсуждалось ранее, в зависимости от типа ссылки, которую переменная из стека содержит на объект из кучи, в определенный момент времени этот объект становится подходящим для сборщика мусора.
Объекты, подходящие для сборки мусора
Например, все объекты, отмеченные красным цветом, могут быть собраны сборщиком мусора. Вы можете заметить, что в куче есть объект, который имеет строгие ссылки на другие объекты, которые также находятся в куче (например, это может быть список, который имеет ссылки на его элементы, или объект, имеющий два поля типа, на которые есть ссылки). Однако, поскольку ссылка из стека потеряна, к ней больше нельзя получить доступ, так что это тоже мусор.
Чтобы углубиться в детали, давайте сначала упомянем несколько вещей:
Этот процесс запускается автоматически Java, и Java решает, запускать или нет этот процесс.
На самом деле это дорогостоящий процесс. При запуске сборщика мусора все потоки в вашем приложении приостанавливаются (в зависимости от типа GC, который будет обсуждаться позже).
На самом деле это более сложный процесс, чем просто сбор мусора и освобождение памяти.
Несмотря на то, что Java решает, когда запускать сборщик мусора, вы можете явно вызвать System.gc() и ожидать, что сборщик мусора будет запускаться при выполнении этой строки кода, верно?
Это ошибочное предположение.
Вы только как бы просите Java запустить сборщик мусора, но, опять же, Java решать, делать это или нет. В любом случае явно вызывать System.gc() не рекомендуется.
Поскольку это довольно сложный процесс и может повлиять на вашу производительность, он реализован разумно. Для этого используется так называемый процесс «Mark and Sweep». Java анализирует переменные из стека и «отмечает» все объекты, которые необходимо поддерживать в рабочем состоянии. Затем все неиспользуемые объекты очищаются.
Так что на самом деле Java не собирает мусор. Фактически, чем больше мусора и чем меньше объектов помечены как живые, тем быстрее идет процесс. Чтобы сделать это еще более оптимизированным, память кучи на самом деле состоит из нескольких частей. Мы можем визуализировать использование памяти и другие полезные вещи с помощью JVisualVM, инструмента, поставляемого с Java JDK. Единственное, что вам нужно сделать, это установить плагин с именем Visual GC, который позволяет увидеть, как на самом деле структурирована память. Давайте немного увеличим масштаб и разберем общую картину:
Поколения памяти кучи
Когда объект создается, он размещается в пространстве Eden (1). Поскольку пространство Eden не такое уж большое, оно заполняется довольно быстро. Сборщик мусора работает в пространстве Eden и помечает объекты как живые.
Если объект выживает в процессе сборки мусора, он перемещается в так называемое пространство выжившего S0(2). Во второй раз, когда сборщик мусора запускается в пространстве Eden, он перемещает все уцелевшие объекты в пространство S1(3). Кроме того, все, что в настоящее время находится на S0(2), перемещается в пространство S1(3).
Если объект выживает в течение X раундов сборки мусора (X зависит от реализации JVM, в моем случае это 8), скорее всего, он выживет вечно и перемещается в пространство Old(4).
Принимая все сказанное выше, если вы посмотрите на график сборщика мусора (6), каждый раз, когда он запускается, вы можете увидеть, что объекты переключаются на пространство выживших и что пространство Эдема увеличивалось. И так далее. Старое поколение также может быть обработано сборщиком мусора, но, поскольку это большая часть памяти по сравнению с пространством Eden, это происходит не так часто. Метапространство (5) используется для хранения метаданных о ваших загруженных классах в JVM.
Представленное изображение на самом деле является приложением Java 8. До Java 8 структура памяти была немного другой. Метапространство на самом деле называется PermGen область. Например, в Java 6 это пространство также хранит память для пула строк. Поэтому, если в вашем приложении Java 6 слишком много строк, оно может аварийно завершить работу.
Типы сборщиков мусора
Фактически, JVM имеет три типа сборщиков мусора, и программист может выбрать, какой из них следует использовать. По умолчанию Java выбирает используемый тип сборщика мусора в зависимости от базового оборудования.
3. Mostly concurrent GC (В основном параллельный сборщик мусора). Если вы помните, ранее в этой статье упоминалось, что процесс сбора мусора на самом деле довольно дорогостоящий, и когда он выполняется, все потоки приостанавливаются. Однако у нас есть в основном параллельный тип GC, который утверждает, что он работает одновременно с приложением. Однако есть причина, по которой он «в основном» параллелен. Он не работает на 100% одновременно с приложением. Есть период времени, на который цепочки приостанавливаются. Тем не менее, пауза делается как можно короче для достижения наилучшей производительности сборщика мусора. На самом деле существует 2 типа в основном параллельных сборщиков мусора:
Примечание переводчика. Информация про сборщики мусора для различных версий Java приведена в переводе:
Советы и приемы
Чтобы минимизировать объем памяти, максимально ограничьте область видимости переменных. Помните, что каждый раз, когда выскакивает верхняя область видимости из стека, ссылки из этой области теряются, и это может сделать объекты пригодными для сбора мусора.
Явно устанавливайте в null устаревшие ссылки. Это сделает объекты, на которые ссылаются, подходящими для сбора мусора.
Избегайте финализаторов (finalizer). Они замедляют процесс и ничего не гарантируют. Фантомные ссылки предпочтительны для работы по очистке памяти.
JVisualVM также имеет функцию создания дампа кучи в определенный момент, чтобы вы могли анализировать для каждого класса, сколько памяти он занимает.
Настройте JVM в соответствии с требованиями вашего приложения. Явно укажите размер кучи для JVM при запуске приложения. Процесс выделения памяти также является дорогостоящим, поэтому выделите разумный начальный и максимальный объем памяти для кучи. Если вы знаете его, то не имеет смысла начинать с небольшого начального размера кучи с самого начала, JVM расширит это пространство памяти. Указание параметров памяти выполняется с помощью следующих параметров:
Если приложение Java выдает ошибку OutOfMemoryError и вам нужна дополнительная информация для обнаружения утечки, запустите процесс с –XX:HeapDumpOnOutOfMemory параметром, который создаст файл дампа кучи, когда эта ошибка произойдет в следующий раз.