Перейти к содержимому

Как работает java

  • автор:

Что такое Java?

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

Для чего используется язык программирования Java?

Для чего используется язык программирования Java?

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

1. Разработка игр

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

2. Облачные вычисления

Язык Java часто называют WORA (Write Once and Run Anywhere – «Напиши один раз, запускай где угодно»), что делает его идеальным для децентрализованных облачных приложений. Поставщики облачных услуг выбирают язык Java для запуска программ на широком спектре базовых платформ.

3. Большие данные

Язык Java используется для механизмов обработки данных, которые могут работать со сложными наборами данных и большими объемами данных в режиме реального времени.

4. Искусственный интеллект

Java – это кладезь библиотек машинного обучения. Благодаря своей стабильности и скорости язык стал выбором № 1 для разработки приложений искусственного интеллекта, таких как обработка естественного языка и глубокое обучение.

5. Интернет вещей

Язык Java используется для программирования датчиков и аппаратного обеспечения периферийных устройств, которые могут независимо подключаться к Интернету.

Почему язык Java так популярен среди современных разработчиков ПО?

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

Высококачественные учебные ресурсы

Поскольку Java существует уже давно, для новых программистов доступно множество учебных ресурсов. Подробная документация, исчерпывающие печатные материалы и курсы помогают разработчикам на протяжении всего обучения. Кроме того, новички могут начать писать код на Core Java, прежде чем переходить на Advanced Java.

Встроенные функции и библиотеки

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

Активная поддержка сообщества

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

Высококачественные инструменты разработки

Язык Java предлагает различные инструменты для поддержки автоматизированного редактирования, отладки, тестирования, развертывания и управления изменениями. Эти инструменты делают программирование на Java экономичным и быстрым.

Независимость от платформы

Код Java может работать на любой базовой платформе, такой как Windows, Linux, iOS или Android, без перезаписи. Таким образом, язык особенно эффективен в современной среде, где приложения запускаются на нескольких устройствах.

Безопасность

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

Как работает Java?

Все языки программирования являются средством общения с машинами. Аппаратное обеспечение машины реагирует только на электронную связь. Языки программирования высокого уровня, такие как Java, играют роль моста между человеческим и аппаратным языком. Для использования Java разработчики должны понимать две вещи.

1. Язык Java и API

Это внешний интерфейс между разработчиком и платформой Java.

2. Виртуальная машина Java

Это внутренняя связь между платформой Java и базовым аппаратным оборудованием. Подробное описание см. ниже.

Что такое виртуальная машина Java?

Виртуальная машина Java действует как дополнительный уровень абстракции между платформой Java и базовым аппаратным обеспечением машины. Исходный код Java может работать только на тех машинах, на которых установлена виртуальная машина Java (Java Virtual Machine, JVM). Ответ на вопрос, зачем нужна виртуальная машина Java, лежит в истории программирования.

История программирования

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

  1. Компиляторы. Вся программа написана в естественном английском синтаксисе с помощью компилирующих программ, а затем язык компилирует (или переводит) весь код в машинный код. После этого скомпилированный код запускается на оборудовании.
  2. Интерпретаторы. С помощью интерпретирующих программ каждое высокоуровневое выражение кода интерпретируется в машинный код в режиме реального времени. Зафиксированные предписания немедленно выполняются аппаратным обеспечением перед просмотром следующего предписания.

Среда времени выполнения Java

Программа Java была первым языком, объединившим оба описанных выше метода с использованием JVM. Компилятор кода Java называется виртуальной машиной Java. Любой файл Java сначала компилируется в байт-код. Байт-код Java может работать только в JVM. Затем JVM интерпретирует байт-код для запуска на базовой аппаратной платформе. Поэтому, если приложение работает на компьютере с Windows, JVM интерпретирует его для Windows. Однако при работе на платформе с открытым исходным кодом, такой как Linux, JVM интерпретирует его для Linux.

Как программировать на Java

Чтобы начать программировать на Java, необходимо установить Java Edition в системе. Существует четыре основные версии Java:

  1. стандартная версия Java (Java Standard Edition, Java SE);
  2. корпоративная версия Java (Java Enterprise Edition, Java EE);
  3. микроверсия Java (Java Micro Edition, Java ME).

Что такое Java SE?

Стандартная версия Java – это основная платформа программирования Java. Такая версия содержит все библиотеки и API, которые нужны любому программисту для разработки на Java. Open Java Development Kit (OpenJDK) – это бесплатная реализация Java SE с открытым исходным кодом.

Amazon Corretto – это бесплатная многоплатформенная, готовая к использованию версия пакета средств разработки OpenJDK. Сервис можно использовать в качестве замены для многих дистрибутивов Java SE, при этом он поставляется с бесплатной долгосрочной поддержкой Amazon. Сервис позволяет запускать одну и ту же среду в облаке, локально и на локальном компьютере.

Что такое AWS SDK для Java?

AWS SDK для Java упрощает использование сервисов AWS, предоставляя упорядоченный набор библиотек, с которыми знакомы разработчики Java. AWS SDK for Java также поддерживает более высокий уровень абстракций для упрощения разработки. Доступны библиотеки Java с открытым исходным кодом, ориентированные на AWS, а также примеры кода и справочное руководство по API Java.

Примеры кода SDK содержат примеры кода на языке Java и реальные примеры работы с сервисами AWS, которые ускорят разработку собственных приложений. Кроме того, справочник по Java API описывает работу API в новейшей версии AWS SDK для Java. Кроме того, приводятся образцы запросов, ответов и список ошибок для поддерживаемых сетевых протоколов.

Начните работать с AWS SDK для Java, используя руководство для разработчиков, или посетите центр разработчиков AWS Java.

Как работает виртуальная машина Java — взгляд изнутри

Каждому Java-разработчику стоит знать, как устроена JVM. Если вы ещё ничего об этом не знаете, то эта статья исправит это упущение.

Обложка поста Как работает виртуальная машина Java — взгляд изнутри

Рассказывает Роман Иванов

Каждому Java-разработчику будет очень полезно понимать, что из себя представляет JVM, как в неё попадает код и как он исполняется. Статья больше подойдёт новичкам, но найти в ней что-то новое смогут и более опытные программисты. В статье вкратце описано, как устроен class-файл и как виртуальная машина обрабатывает и исполняет байт-код.

Основной задачей разработчиков Java было создание переносимых приложений. JVM играет центральную роль в переносимости — она обеспечивает должный уровень абстракции между скомпилированной программой и базовой аппаратной платформой и операционной системой. Несмотря на этот дополнительный «слой», скорость работы приложений необычайно высока, потому что байт-код, который выполняет JVM, и она сама отлично оптимизированы.

Рассмотрим схему работы JVM более подробно.

Структура class-файла

Напишем простейшее приложение и скомпилируем его. Компилятор заботливо создаст файл с расширением class и поместит туда всю информацию о нашем мини-приложении для JVM. Что мы увидим внутри? Файл поделён на десять секций, последовательность которых строго задана и определяет всю структуру class-файла.

Файл начинается со стартового (магического) числа: 0xCAFEBABE. Данное число присутствует в каждом классе и является обязательным флагом для JVM: с его помощью система понимает, что перед ней class-файл.

Как работает виртуальная машина Java — взгляд изнутри 1

Следующие четыре байта class-файла содержат старший и младший номера версий Java. Они идентифицируют версию формата конкретного class-файла и позволяют JVM проверять, возможна ли его поддержка и загрузка. Каждая JVM имеет ограничение версии, которую она может загрузить — более поздние версии будут игнорироваться. Как видно на примере файла выше, у нас major версия 0x34 , что соответствует Java SE 8. Для Java SE 11 будет значение 0x37 .

С девятого байта идёт пул констант, в котором содержатся все константы нашего класса. Так как в каждом классе их может быть различное количество, то перед массивом находится переменная, указывающая на его длину, то есть пул констант представляет из себя массив переменной длины. Каждая константа занимает один элемент в массиве. Во всём class-файле константы указываются целочисленным индексом, который обозначает их положение в массиве. Начальная константа имеет индекс 1, вторая константа — 2 и т. д.

Каждый элемент пула констант начинается с однобайтового тега, определяющего его тип. Это позволяет JVM понять, как правильно обработать идущую далее константу. Всего зарезервировано 14 типов констант:

На данный момент этот блок не поддерживается, но мы не забыли о нём! Наша команда уже занята его разработкой, он будет доступен в ближайшее время.

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

Прочитав блок с константами, JVM переходит к следующим двум байтам — флагам доступа, которые определяют, описывает этот файл класс или интерфейс, общедоступный или абстрактный, является ли класс финальным.

Имена класса и его родительского класса хранятся в массиве констант, на которые указывают последующие 4 байта в файле.

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

На данный момент этот блок не поддерживается, но мы не забыли о нём! Наша команда уже занята его разработкой, он будет доступен в ближайшее время.

Подобную структуру имеет и следующий блок — Fields.

Этот блок начинается с двухбайтового параметра количества полей в этом классе или интерфейсе. За ним идёт массив структур переменной длины. Каждая структура содержит информацию об одном поле: имя поля, тип, значение, если это, например, финальная переменная. В списке отображаются только те поля, которые были объявлены классом или интерфейсом, определённым в файле. Поля от родительских классов и имплементированных интерфейсов здесь не присутствуют, они задаются в своих class-файлах.

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

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

В последнем блоке идёт дополнительная мета-информация, например имя файла, который был скомпилирован. Она может присутствовать, а может и нет. В случае каких-то проблем JVM просто игнорирует этот блок.

Мы рассмотрели структуру файлов и готовы перейти к следующей части — загрузке class-файла в JVM и последующему выполнению байт-кода из этого класса. В качестве закрепления полученных знаний по структуре class-файла можете воспользоваться встроенным декомпилятором Java и посмотреть результат его выполнения с ключами -c -verbose (javap -c -verbose TestJava.class) .

Загрузка классов

Теперь, разобравшись с общей структурой файла, посмотрим, как JVM его обрабатывает.

Чтобы попасть в JVM, класс должен быть загружен. Для этого существуют специальные классы-загрузчики:

  1. Bootstrap — базовый загрузчик, загружает платформенные классы. Этот загрузчик является родителем всех остальных классов и частью платформы.
  2. Extension ClassLoader — загрузчик расширений, потомок Bootstrap-загрузчика. Загружает классы расширений, которые по умолчанию находятся в каталоге jre/lib/ext .
  3. AppClassLoader — системный загрузчик классов из classpath, который является непосредственным потомком Extension ClassLoader. Он загружает классы из каталогов и jar-файлов, указанных переменной среды CLASSPATH , системным свойством java.class.path или параметром командной строки -classpath .
  4. Собственный загрузчик — у приложения могут быть свои собственные загрузчики.

Главный класс приложения всегда загружается системным загрузчиком, остальные же классы могут быть загружены различными пользовательскими загрузчиками. Стоит упомянуть, что имя загрузчика создаёт уникальное пространство имён, то есть в программе может существовать несколько классов с одним и тем же полным именем, если они обрабатывались разными загрузчиками.
Поэтому каждый загрузчик делегирует свои полномочия родителю, то есть перед поиском класса для загрузки он попытается узнать, не был ли загружен нужный класс раньше.

После загрузки класса начинается этап линковки, который делится на три части.

  1. Верификация байт-кода. Это статический анализ кода, выполняется один раз для класса. Система проверяет, нет ли ошибок в байт-коде. Например, проверяет корректность инструкций, переполнение стека и совместимость типов переменных.
  2. Выделение памяти под статические поля и их инициализация.
  3. Разрешение символьных ссылок — JVM подставляет ссылки на другие классы, методы и поля. В большинстве случаев это происходит лениво, то есть при первом обращении к классу.

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

JVM получает один поток байтовых кодов для каждого метода в классе. Байт-код метода выполняется, когда этот метод вызывается в ходе работы программы. Поток байт-кода метода — это последовательность инструкций для виртуальной машины Java. Каждая инструкция состоит из однобайтового кода операции, за которым может следовать несколько операндов. Код операции указывает действие, которое нужно предпринять. Всего на данный момент в Java более 200 операций. Все коды операций занимают только 1 байт, так как они были разработаны компактными, поэтому их максимальное число не может превысить 256 штук.

В основе работы JVM находится стек — основные инструкции работают с ним.

Рассмотрим пример умножения двух чисел. Ниже представлен байт-код метода:

0: iconst_1 // взять число 1, положить в стек 1: istore_1 // сохранить это число в переменную 1 стека метода 2: iconst_5 // взять число 5, положить в стек 3: istore_2 // сохранить его в переменную 2 стека метода 4: iload_1 // положить в стек переменную 1 5: iload_2 // положить в стек переменную 2 6: imul // достать из стека два числа, умножить их и положить в стек 7: istore_3 // взять из стека число и сохранить его в переменную 3 

На Java это будет выглядеть так:

int a = 1; int b = 5; int c = a * b 

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

Всего JVM поддерживает семь примитивных типов данных: byte, short, int, long, float, double и char.

Если бы мы хотели положить в переменную а другое значение, например 11112, то нам пришлось бы использовать инструкцию sipush :

0: sipush 11112 3: istore_1 

Данные операции выполняются в так называемом фрейме стека метода. У каждого метода есть некоторая своя часть в общем стеке. Таким образом в нашем главном потоке исполнения программы создаются множество подстеков на каждый вызов метода. Более наглядно это представлено на картинке ниже:

Как работает виртуальная машина Java — взгляд изнутри 2

В каждом стек-фрейме хранится массив локальных переменных, который позволяет сохранять и доставать локальные переменные, как мы сделали в примере выше, поместив значения 1 и 5 в переменные 1 и 2. Стоить отметить, что здесь компилятор также оптимизировал байт-код, используя однобайтовые инструкции. Если бы переменных в нашем методе было много, использовался бы код операции сохранения значения вместе с указанием позиции переменной в массиве.

Чтобы достучаться до пула констант класса и получить нужное значение, используются инструкции lcd и lcd_w . При этом lcd может ссылаться только на константы с индексами от 1 до 255, поскольку размер её операнда составляет всего 1 байт. Lcd_w имеет 2-байтовый индекс, поэтому может ссылаться на более широкий диапазон индексов.

Вызовы методов

Java предоставляет два основных вида методов: методы экземпляра и методы класса. Методы экземпляра используют динамическое (позднее) связывание, тогда как методы класса используют статическое (раннее) связывание.

Виртуальная машина Java вызывает метод класса, выбирая его на основании типа ссылки на объект, который всегда известен во время компиляции. С другой стороны, когда виртуальная машина вызывает метод экземпляра, она выбирает метод для вызова на основе фактического класса объекта, который может быть известен только во время выполнения. Поэтому для вызова методов используются разные инструкции: invokevirtual и invokestatic . Данные функции ссылаются на запись в пуле констант в виде полного пути к необходимой функции. Виртуальная машина снимает нужное количество переменных со стека и передает в метод.

Возвращаемое методом значение кладётся на стек. Типы возвращаемых значений методов указаны ниже:

На данный момент этот блок не поддерживается, но мы не забыли о нём! Наша команда уже занята его разработкой, он будет доступен в ближайшее время.

Циклы

Осталось рассмотреть последнюю часто используемую конструкцию языка — циклы. Посмотрим, во что превратится код, представленный ниже:

int i = 1000; while (i
0: sipush 1000 3: istore_1 4: iload_1 5: sipush 9999 8: if_icmpge 17 11: iinc 1, 10 14: goto 4 17: return 

Каждый раз на стеке оказывается два числа, которые сравниваются, и если i > 9999 , происходит выход из цикла. При этом для создания цикла используется конструкция на основе goto , которая запрещена в самом языке Java, хотя ключевое слово и зарезервировано.

Заключение

Изначально байт-код интерпретируется в большинстве JVM, но как только система замечает, что некоторый код используется очень часто, она подключает встроенный компилятор, который компилирует байт-коды в машинный код, тем самым значительно ускоряя работу приложения.

Таким образом, мы поверхностно рассмотрели жизненный цикл байткода в JVM: class-файлы, их загрузку и выполнение байт-кода и базовые инструкции.

Архитектура виртуальной машины Java: объяснение для начинающих

Независимо от того, приходилось ли вам разрабатывать на Java, вы, вероятно, слышали о виртуальной машине Java (JVM).

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

JVM изначально разрабатывалась исключительно для поддержки Java. Однако со временем на платформе Java обосновались многие другие языки, такие как Scala, Kotlin и Groovy. Все они в совокупности называются языками JVM.

В этой статье мы расскажем больше о JVM: как она работает и из каких компонентов состоит.

Что такое виртуальная машина?

Прежде чем переходить к JVM, остановимся на самой концепции виртуальной машины (ВМ).

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

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

Что такое виртуальная машина Java?

В языках программирования, таких как C и C++, код сначала компилируется в машинный для конкретной платформы. Эти языки называются компилируемыми языками.

С другой стороны, в таких языках, как JavaScript и Python, компьютер выполняет инструкции напрямую, без необходимости компиляции. Эти языки называются интерпретируемыми.

Java использует комбинацию обоих методов. Код Java сначала компилируется в байтовый код и генерирует файл класса ( .class ). Этот файл класса затем интерпретируется виртуальной машиной Java для базовой платформы. Один и тот же файл класса может выполняться на любой версии JVM, на любой платформе и операционной системе.

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

Архитектура виртуальной машины Java

JVM состоит из трех отдельных компонентов:

  • загрузчик классов;
  • область памяти/данных среды выполнения;
  • механизм выполнения.

Рассмотрим каждый из них более подробно.

Загрузчик классов

Когда вы компилируете исходный файл .java , он преобразуется в байт-код как файл .class . Когда вы вызываете этот класс у себя в программе, загрузчик классов загружает его в основную память.

Как правило, первым в память загружается класс, содержащий метод main() .

Процесс загрузки класса состоит из трех этапов: загрузка, связывание и инициализация.

Загрузка

Загрузка включает бинарную репрезентацию (байт-код) класса или интерфейса с определенным именем и создание на его основе исходного класса или интерфейса.

В Java доступны три встроенных загрузчика классов:

  • Загрузчик классов начальной загрузки(Bootstrap Class Loader) — корневой загрузчик классов. Это суперкласс загрузчика классов расширений, который загружает стандартные пакеты Java, такие как java.lang , java.net , java.util , java.io и так далее. Эти пакеты находятся внутри rt.jar и других основных библиотек, присутствующих в каталоге $JAVA_HOME/jre/lib .
  • Загрузчик классов расширений (Extension Class Loader) — подкласс загрузчика классов начальной загрузки и суперкласс загрузчика классов приложений. Он загружает расширения стандартных библиотек Java, которые присутствуют в каталоге $JAVA_HOME/jre/lib/ext .
  • Загрузчик классов приложений (Application Class Loader) — конечный загрузчик классов и подкласс загрузчика классов расширений. Он загружает файлы, которые находятся в пути к классам (classpath). По умолчанию путь к классу устанавливается как текущий каталог приложения. Путь к классу также можно изменить, добавив параметр командной строки -classpath или -cp .

JVM использует метод ClassLoader.loadClass() для загрузки класса в память. Он пытается загрузить класс на основе полного имени.

Если родительский загрузчик классов не может найти класс, он делегирует работу дочернему загрузчику классов. Если последний загрузчик также не может загрузить класс, он создает исключение NoClassDefFoundError или ClassNotFoundException .

Связывание

После загрузки класса в память происходит процесс связывания. Связывание класса или интерфейса предполагает объединение различных элементов и зависимостей программы.

Связывание включает следующие шаги.

  • Проверка. На этом этапе проверяется структурная корректность файла .class путем проверки его на соответствие набору ограничений и правил. Если проверка по какой-либо причине завершается неудачей, выбрасывается исключение VerifyException .

Например, если код был создан на Java 11, но выполняется в системе, где установлена Java 8, этап проверки завершится неудачно.

  • Подготовка. На этом этапе JVM выделяет память для статических полей класса или интерфейса и инициализирует их значениями по умолчанию.

Предположим, что вы объявили в классе следующую переменную:

private static final boolean enabled = true;

На этапе подготовки JVM выделяет память для переменной enabled и устанавливает ее значение в значение по умолчанию для логического значения, которое равно false .

  • Решение. На этом этапе символические ссылки заменяются прямыми, присутствующими в пуле констант времени выполнения.

Например, если у вас есть ссылки на другие классы или постоянные переменные, присутствующие в других классах, они разрешаются на этом этапе и заменяются их фактическими ссылками.

Инициализация

Инициализация включает выполнение метода инициализации класса или интерфейса (известного как ). Сюда может входить вызов конструктора класса, выполнение статического блока и присвоение значений всем статическим переменным. Это заключительный этап загрузки класса.

К примеру, ранее мы объявили следующее:

private static final boolean enabled = true;

На этапе подготовки переменной enabled было присвоено значение по умолчанию false . На этапе инициализации этой переменной присваивается ее фактическое значение true .

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

Область данных среды выполнения

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

Рассмотрим каждый из них в отдельности.

Область метода

Здесь хранятся все данные уровня класса, такие как пул констант времени выполнения, данные полей и методов, а также код методов и конструкторов.

Если памяти, доступной в области метода, недостаточно для запуска программы, JVM выдает ошибку OutOfMemoryError .

Например, предположим, что мы объявили следующий класс:

public class Employee  
private String name;
private int age;

public Employee(String name, int age)
this.name = name;
this.age = age;
>
>

В этом примере данные уровня поля, такие как name и age , а также сведения о конструкторе загружаются в область метода.

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

Область кучи

Здесь хранятся все объекты и соответствующие им переменные экземпляра. Это область данных времени выполнения, из которой выделяется память для всех экземпляров классов и массивов.

Например, предположим, вы объявили следующий экземпляр:

Employee employee = new Employee();

В этом примере создается экземпляр класса Employee и загружается в область кучи.

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

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

Область стека

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

Если для обработки в потоке требуется больший размер стека, чем доступно, JVM выдает ошибку StackOverflowError .

Для каждого вызова метода в памяти стека делается одна запись, которая называется фреймом стека. Когда вызов метода завершен, фрейм стека уничтожается.

Фрейм стека разделен на три части.

  • Локальные переменные. Каждый фрейм содержит массив переменных, известных как его локальные переменные. Здесь хранятся все локальные переменные и их значения. Длина этого массива определяется во время компиляции.
  • Стек операндов. Каждый фрейм содержит стек последним-вошел-первым-вышел (last-in-first-out, LIFO), известный как стек операндов. Он действует как рабочая область среды выполнения для любых промежуточных операций. Максимальная глубина этого стека определяется во время компиляции.
  • Данные фрейма. Здесь хранятся все символы, соответствующие методу. Здесь также хранится информация о блоке catch на случай исключений.

К примеру, есть следующий код:

double calculateNormalisedScore(List answers)  
double score = getScore(answers);
return normalizeScore(score);
>

double normalizeScore(double score)
return (score – minScore) / (maxScore – minScore);
>

В этом примере кода переменные, такие как answers и score , помещаются в массив локальных переменных. Стек операндов содержит переменные и операторы, необходимые для выполнения математических операций вычитания и деления.

Примечание: поскольку область стека не является общей, она по своей сути потокобезопасна.

Регистры счетчика программ

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

Стеки нативных методов

JVM содержит стеки, которые поддерживают нативные методы, то есть такие методы, которые написаны на языке, отличном от Java, например C или C++. Для каждого нового потока также выделяется отдельный стек нативных методов.

Система выполнения

Как только байт-код загружен в основную память, и подробная информация становится доступна в области данных среды выполнения, наступает следующий этап — запуск программы. Механизм выполнения делает это, выполняя код из каждого класса.

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

Интерпретатор

Интерпретатор считывает и выполняет инструкции байт-кода строка за строкой. Из-за построчного выполнения интерпретатор работает сравнительно медленнее.

Еще один недостаток интерпретатора — при многократном вызове метода каждый раз требуется новая интерпретация.

JIT-компилятор

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

Затем JIT-компилятор компилирует весь байт-код и изменяет его на собственный машинный код. Этот собственный машинный код используется непосредственно для повторных вызовов методов, что повышает производительность системы.

JIT-компилятор содержит следующие компоненты.

  • Генератор промежуточного кода — генерирует промежуточный код.
  • Оптимизатор кода — оптимизирует промежуточный код для повышения производительности.
  • Генератор целевого кода — преобразует промежуточный код в собственный машинный код.
  • Профилировщик — находит горячие точки (код, который выполняется повторно).

Чтобы лучше понять разницу между интерпретатором и JIT-компилятором, предположим, что у вас есть следующий код:

int sum = 10;
for(int i = 0 ; i sum += i;
>
System.out.println(sum);

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

Однако JIT-компилятор распознает, что в этом коде есть “горячая точка”, и выполнит оптимизацию. Он сохранит локальную копию sum в регистре для потока и будет продолжать добавлять значение i в цикле. Как только цикл завершится, компилятор запишет значение sum обратно в память.

Примечание: компилятору требуется больше времени для компиляции кода, чем интерпретатору для интерпретации кода строка за строкой. Если вы намерены запустить программу только один раз, интерпретатор будет предпочтительнее.

Сборщик мусора

Сборщик мусора (Garbage Collector, GC) собирает и удаляет объекты без ссылок из области кучи. Это процесс автоматического восстановления неиспользуемой памяти во время выполнения путем уничтожения мусорных объектов.

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

  • Пометка — на этом этапе GC идентифицирует неиспользуемые объекты в памяти.
  • Очистка — на этом этапе GC удаляет объекты, идентифицированные на предыдущем этапе.

Сборка мусора выполняется JVM автоматически через регулярные промежутки времени и не требует отдельной обработки. Ее также можно запустить вызовом System.gc() , но выполнение не гарантируется.

JVM содержит три различных типа сборщиков мусора.

  • Последовательная сборка мусора. Это самая простая реализация GC. Она предназначена для небольших приложений, работающих в однопоточных средах. Для сборки мусора используется один поток. Запуск приводит к событию “остановки мира”, когда все приложение приостанавливает работу. Аргумент JVM для запуск последовательного сборщика мусора: -XX:+UseSerialGC .
  • Параллельная сборка мусора. Это реализация GC по умолчанию, также известная как сборщик пропускной способности. Для сборки мусора в нем используется несколько потоков, но работа приложения все равно приостанавливается при запуске. Аргумент JVM для параллельного сборщика мусора: -XX:+UseParallelGC .
  • Garbage First (G1). G1 был разработан для многопоточных приложений с большим доступным размером кучи (более 4 ГБ). Он разбивает кучу на набор областей одинакового размера и использует несколько потоков для их сканирования. G1-сборщик определяет регионы с наибольшим количеством мусора и сначала выполняет сбор мусора в них. Аргумент JVM для этого сборщика мусора: -XX:+UseG1GC .

Примечание: существует другой тип сборщика мусора, называемый сборщиком параллельных меток (CMS). Однако он устарел начиная с Java 9 и полностью удален в Java 14, и его место занимает сборщик G1.

Нативный интерфейс Java (Java Native Interface, JNI)

Иногда необходимо задействовать в работе нативный (не Java) код (например, написанный на C/C++). К примеру, в тех случаях, когда нужно взаимодействовать с физическим оборудованием или преодолевать ограничения по управлению памятью и производительности в Java. Java поддерживает выполнение нативного кода через нативный интерфейс Java (JNI).

JNI действует как мост для предоставления вспомогательных пакетов другим языкам программирования, таким как C, C++ и так далее. Это особенно полезно в тех случаях, когда нужно написать код, который не полностью поддерживается Java, например, некоторые специфичные для платформы функции могут быть написаны только на C.

Вы можете воспользоваться ключевым словом native , чтобы указать, что реализация метода будет предоставлена нативной библиотекой. Также потребуется вызвать System.LoadLibrary() , чтобы загрузить общую нативную библиотеку в память и сделать ее функции доступными для Java.

Нативные библиотеки методов

Нативные библиотеки методов — это библиотеки, написанные на других языках программирования, таких как C, C++ и ассемблер. Эти библиотеки обычно представлены в виде файлов .dll или .so . Такие библиотеки можно загружать через JNI.

Распространенные ошибки JVM

  • ClassNotFoundException . Происходит, когда загрузчик классов пытается загрузить классы с помощью Class.forName() , ClassLoader.loadClass() или ClassLoader.findsystemclass() , но определение класса с указанным именем не найдено.
  • NoClassDefFoundError . Происходит, когда компилятор успешно скомпилировал класс, но загрузчик классов не может найти файл класса во время выполнения.
  • OutOfMemoryError . Происходит, когда JVM не может выделить объект из-за нехватки памяти, и сборщик мусора не может предоставить больше памяти.
  • StackOverflowError . Происходит, если в JVM не хватает места при создании новых кадров стека во время обработки потока.

Заключение

В этой статье мы обсудили архитектуру виртуальной машины Java и ее компоненты. Часто мы не вникаем глубоко во внутреннюю механику JVM или не интересуемся, как она работает, пока работает код.

Только когда что-то идет не так, и нам нужно настроить JVM или устранить утечку памяти, мы пытаемся понять ее внутреннее устройство.

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

  • 9 вещей, которыми следует заняться Java программисту в 2018 году
  • Превратите свой Java-код в полностью асинхронный
  • Циклы Java в сторону — даешь потоки!

Компиляция и исполнение Java приложений под капотом

Java-университет

Всем привет! Сегодня я хотел бы поделиться знаниями о том, что происходит под капотом JVM (Java Virtual Machine) после того, как мы запускаем написанное Java приложение. В наше время существуют моднейшие среды разработки, которые помогают не думать о внутреннем устройстве JVM, компиляции и выполнении Java-кода, из за чего новые разработчики могут упустить эти важные аспекты. В то же время, на собеседованиях часто задают вопросы касательно этой темы, из-за чего я и решил написать статью.

2. Компиляция в байт-код

Компиляция и исполнение Java приложений под капотом - 2

Начнем с теории. Когда мы пишем какое-либо приложение, мы создаем файл с расширением .java и помещаем в него код на языке программирования Java. Такой файл, содержащий код, понятный человеку, называется файлом с исходным кодом. После того, как файл с исходным кодом готов, нужно его выполнить! Но на стадии в нем содержится информация, понятная только человеку. Java — мультиплатформенный язык программирования. Это значит, что программы, написанные на языке Java, можно выполнять на любой платформе, где установлена специальная исполняющая система Java. Такая система называется Java Virtual Machine (JVM). Для того, чтобы перевести программу из исходного кода в код, понятный JVM, нужно её скомпилировать. Код, понятный JVM называется байт-кодом и содержит набор инструкций, которые в дальнейшем будет исполнять виртуальная машина. Для компиляции исходного кода в байт-код существует компилятор javac , входящий в поставку JDK (Java Development Kit). На вход компилятор принимает файл с расширением .java , содежащий исходный код программы, а на выходе выдает файл с расширением .class , содержащий байт-код, необходимый для исполнения программы виртуальной машиной. После того, как программа была скомпилирована в байт-код, она может быть выполнена с помощью виртуальной машины.

3. Пример компиляции и выполнения программы

Предположим, что у нас есть простая программа, содержащаяся в файле Calculator.java , которая принимает 2 численных аргумента командной строки и печатает результат их сложения:

 class Calculator < public static void main(String[] args)< int a = Integer.valueOf(args[0]); int b = Integer.valueOf(args[1]); System.out.println(a + b); >> 

Для того, чтобы скомпилировать эту программу в байт-код, воспользуемся компилятором javac в командной строке:

 javac Calculator.java 

После компиляции на выходе мы получаем файл с байт-кодом Calculator.class , который мы можем исполнить при помощи установленной на нашем компьютере java-машины командой java в командной строке:

 java Calculator 1 2 

Заметим, что после названия файла были указаны 2 аргумента командной строки — числа 1 и 2. После выполнения программы, в командной строке выведется число 3. В примере выше у нас был простой класс, который живет сам по себе. Но что, если класс находится в каком либо пакете? Смоделируем такую ситуацию: создадим директории src/ru/javarush и поместим туда наш класс. Теперь он выглядит следующим образом (добавили имя пакета в начале файла):

 package ru.javarush; class Calculator < public static void main(String[] args)< int a = Integer.valueOf(args[0]); int b = Integer.valueOf(args[1]); System.out.println(a + b); >> 

Скомпилируем такой класс следующей командой:

 javac -d bin src/ru/javarush/Calculator.java 

В этом примере мы использовали дополнительную опцию компилятора -d bin , которая складывает скомпилированные файлы в директорию bin со структурой, аналогичной директории src , при этом директория bin должна быть создана заранее. Такой прием используется, чтобы не путать файлы с исходным кодом с файлами с байт-кодом. Перед запуском скомпилированной программы стоит пояснить понятие classpath . Classpath — это путь, относительно которого виртуальная машина будет искать пакеты и скомпилированные классы. Тоесть, таким образом мы говорим виртуальной машине какие директории в файловой системе являются корневыми для иерархии пакета Java. Classpath можно укзать при запуска программы с помощью флага -classpath . Запуск программы осуществляем с помощью команды:

 java -classpath ./bin ru.javarush.Calculator 1 2 

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

 ├── src │ └── ru │ └── javarush │ └── Calculator.java └── bin └── ru └── javarush └── Calculator.class 

4. Выполнение программы виртуальной машиной

Итак, мы запустили написанную программу. Но что же происходит в момент запуска скомпилированной программы виртуальной машиной? Для начала разберемся, что означают понятия компиляции и интерпретации кода. Компиляция — трансляция программы, составленной на исходном языке высокого уровня, в эквивалентную программу на низкоуровневом языке, близком машинному коду. Интерпретация — пооператорный (покомандный, построчный) анализ, обработка и тут же выполнение исходной программы или запроса (в отличие от компиляции, при которой программа транслируется без её выполнения). Язык Java обладает как компилятором ( javac ), так и интерпретатором, в роли которого выступает виртуальная машина, которая построчно преобразует байт-код в машинный код и тут же его исполняет. Таким образом, когда мы запускаем скомпилированную программу, виртуальная машина начинает её интерпретацию, то есть построчное преобразование байт-кода в машинный код, а так же его исполнение. К сожалению, чистая интерпретация байт-кода является довольно долгим процессом и делает язык java медленным в сравнении с его конкурентами. Дабы избежать этого, был введен механизм, позволяющий ускорить интерпретацию байт-кода виртуальной машиной. Этот механизм называется Just-in-time компиляцией (JITC).

5. Just-in-time (JIT) компиляция

Простыми словами, механизм Just-In-Time компиляции заключается в следующем: если в программе присутствуют части кода, которые выполняются много раз, то их можно скомпилировать один раз в машинный код, чтобы в будущем ускорить их выполнение. После компиляции такой части программы в машинный код, при каждом следующем вызове этой части программы виртуальная машина будет сразу выполнять скомпилированный машинный код, а не интерпретировать его, что естественно ускорит выполнение программы. Ускорение работы программы достигается за счет увеличения потребления памяти (где-то же нам нужно хранить скомпилированный машинный код!) и за счет увеличения временных затрат на компиляцию во время исполнения программы. JIT компиляция — довольно сложный механизм, поэтому пройдемся по верхам. Всего существует 4 уровня JIT компиляции байт-кода в машинный код. Чем выше уровень компиляции, тем он сложнее, но и одновременно выполнение такого участка будет быстрее, чем участка с меньшим уровнем. JIT — компилятор самостоятельно решает, какой уровень компиляции задать для каждого фрагмента программы на основе того, как часто выполняется этот фрагмент. Под капотом JVM использует 2 JIT-компилятора — C1 и C2. C1 компилятор так же называется клиентским компилятором и способен скомпилировать код только до 3-его уровня. За 4-ый, самый сложны и быстрый уровень компиляции отвечает компилятор C2.

Компиляция и исполнение Java приложений под капотом - 3

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

При запуске Java — программы на x32 версии JVM мы в ручную можем указать, какой режим мы хотим использовать, при помощи флагов -client и -server . При указании флага -client JVM не будет производить сложные оптимизации с байт-кодом, что ускорит время старта приложения и уменьшит количество потребляемой памяти. При указании флага -server приложение будет стартовать большее количество времени из-за сложных оптимизаций байт-кода и будет использовать больше памяти для хранения машинного кода, однако в дальнейшем работать такая программа будет быстрее. В x64 версии JVM флаг -client игнорируется и по умолчанию используется серверная конфигурация приложения.

6. Заключение

Компилятор javac преобразует исходный код программы в байт-код, который может быть выполнен на любой платформе, на которой установлена виртуальная машина Java;

После компиляции JVM интерпретирует получившийся байт-код;

Для ускорения работы Java-приложений, JVM использует механизм Just-In-Time компиляции, который преобразует наиболее часто выполняемые участки программы в машинный код и хранит их в памяти.

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *