Значения целочисленных типов виртуальной машины Java:

Типы с плавающей точкой — это float и double, которые концептуально связаны со значениями и операциями формата IEEE 754 с одинарной точностью (32 бита) и двойной точностью (64 бита), как указано в Стандарте IEEE для арифметики с плавающей запятой (ANSI/IEEE Std. 754-1985, Нью-Йорк).

Стандарт IEEE 754 включает не только положительные и отрицательные числа со знаком и абсолютной величиной, но также положительный и отрицательный ноль, положительную и отрицательную бесконечность и специальное значение «Не число» (сокращённо «NaN»). Значение NaN используется для представления результата некоторых недопустимых операций, таких как деление нуля на ноль.

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

Все конечные ненулевые значения любого набора значений с плавающей точкой могут быть выражены в виде s ⋅ m ⋅ 2^{(e − N + 1)}, где s равно +1 или −1, m — положительное целое число, меньшее 2N, а e — целое число от E_min = −(2^K−1−2) до E_max = 2^K−1−1 включительно, где N и K — параметры, зависящие от набора значений. Некоторые значения могут быть представлены в этом виде более чем одним способом; например, предположим, что значение v в наборе значений может быть представлено в этом виде с использованием определённых значений для s, m и e, затем, если m чётное, а e меньше 2^K-1, можно уменьшить m вдвое и увеличить e на 1, чтобы получить второе представление для того же значения v. Представление в этом виде называется нормализованным, если m ≥ 2^N-1; в противном случае представление называется денормализованным. Если значение в наборе значений не может быть представлено таким образом, что m ≥ 2^N-1, то это значение называется денормализованным значением, потому что оно не имеет нормализованного представления.

Ограничения на параметры N и K (и на производные параметры E_min и E_max) для двух необходимых и двух необязательных наборов значений с плавающей точкой приведены в таблице 2.1.

В случае поддержки одной или обеих расширенных наборов значений с расширенным порядком реализацией, для каждого поддерживаемого набора значений с расширенным порядком существует определённая зависимая от реализации константа K, значение которой ограничено таблицей 2.1; это значение K в свою очередь определяет значения для E_min и E_max.

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

Обратите внимание, что ограничения в таблице 2.1 разработаны таким образом, чтобы каждый элемент набора значений float обязательно был также элементом набора значений float с расширенным порядком, набора значений double и набора значений double с расширенным порядком. Аналогично, каждый элемент набора значений double обязательно также является элементом набора значений double с расширенным порядком. Каждый набор значений с расширенным порядком имеет больший диапазон значений показателя степени, чем соответствующий стандартный набор значений, но не имеет большей точности.

Элементы набора значений float — это точно те значения, которые могут быть представлены с использованием формата с плавающей точкой одинарной точности, определённого в стандарте IEEE 754, за исключением того, что существует только одно значение NaN (стандарт IEEE 754 определяет 2²⁴-2 различных значений NaN). Элементы набора значений double — это точно те значения, которые могут быть представлены с использованием формата с плавающей точкой двойной точности, определённого в стандарте IEEE 754, за исключением того, что существует только одно значение NaN (стандарт IEEE 754 определяет 2⁵³-2 различных значений NaN). Однако следует отметить, что элементы наборов значений float с расширенным порядком и double с расширенным порядком, определённые здесь, не соответствуют значениям, которые могут быть представлены с использованием форматов IEEE 754 с расширенной одинарной и расширенной двойной точностью соответственно. Этот документ не предписывает конкретное представление для значений наборов значений с плавающей точкой, за исключением случаев, когда значения с плавающей точкой должны быть представлены в формате файла class (§4.4.4, §4.4.5).

Наборы значений float, float с расширенным порядком, double и double с расширенным порядком — это не типы. Для реализации виртуальной машины Java всегда верно использовать элемент набора значений float для представления значения типа float; однако в определённых контекстах реализация может использовать элемент набора значений float с расширенным порядком вместо этого. Аналогично, для реализации всегда верно использовать элемент набора значений double для представления значения типа double; однако в определённых контекстах реализация может использовать элемент набора значений double с расширенным порядком вместо этого.

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

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

NaN не упорядочены, поэтому числовые сравнения и проверки на числовое равенство принимают значение false, если хотя бы один или оба операнда являются NaN. В частности, проверка числового равенства значения самому себе принимает значение false тогда и только тогда, когда значение равно NaN. Проверка числового неравенства принимает значение true, если один из операндов равен NaN.

Тип returnAddress используется инструкциями виртуальной машины Java jsr, ret и jsr_w (§jsr, §ret, §jsr_w). Значения типа returnAddress — указатели на инструкции виртуальной машины Java. В отличие от числовых примитивных типов, тип returnAddress не соответствует какому-либо типу языка программирования Java и не может быть изменён работающей программой.

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

Виртуальная машина Java напрямую поддерживает массивы boolean. Инструкция newarray (§newarray) позволяет создавать массивы boolean. Элементы массива типа boolean обращаются и изменяются с помощью инструкций для массивов byte baload и bastore (§baload, §bastore).

В реализации виртуальной машины Java от Oracle, массивы boolean в языке программирования Java кодируются как массивы byte виртуальной машины Java, используя 8 бит на каждый элемент boolean.

Виртуальная машина Java кодирует компоненты массива boolean, используя 1 для представления true и 0 для представления false. Там, где компиляторы языка программирования Java преобразуют значения boolean в значения типа int виртуальной машины Java, компиляторы должны использовать такое же кодирование.

Java Virtual Machine может поддерживать множество потоков выполнения одновременно (JLS §17). Каждый поток Java Virtual Machine имеет свой собственный регистр pc (счетчик программ). В любой момент времени каждый поток Java Virtual Machine выполняет код одного метода, а именно текущего метода (§2.6) для этого потока. Если этот метод не native, регистр pc содержит адрес инструкции Java Virtual Machine, которая в данный момент выполняется. Если метод, который в данный момент выполняется потоком, native, значение регистра pc Java Virtual Machine не определено. Регистр pc Java Virtual Machine достаточно широк, чтобы вместить returnAddress или нативный указатель на конкретной платформе.

Каждый поток Java Virtual Machine имеет частный стек Java Virtual Machine, созданный одновременно с потоком. Стек Java Virtual Machine хранит фреймы (§2.6). Стек Java Virtual Machine аналогичен стеку обычного языка, такого как C: он содержит локальные переменные и частичные результаты, а также играет роль в вызове и возврате методов. Поскольку стек Java Virtual Machine никогда не манипулируется напрямую, за исключением добавления и удаления фреймов, фреймы могут быть выделены в куче. Память для стека Java Virtual Machine не обязательно должна быть непрерывной.

В The Java Virtual Machine Specification, First Edition, стек Java Virtual Machine был известен как Java stack.

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

Реализация Java Virtual Machine может предоставить программисту или пользователю управление начальным размером стеков Java Virtual Machine, а также, в случае динамически расширяющихся или сжимающихся стеков Java Virtual Machine, управление максимальным и минимальным размерами.

Со следующими исключительными условиями связаны стеки Java Virtual Machine:

Java Virtual Machine имеет heap, который совместно используется всеми потоками Java Virtual Machine. Heap — это область данных во время выполнения, из которой выделяется память для всех экземпляров классов и массивов.

Heap создается при запуске виртуальной машины. Память Heap для объектов возвращается системой автоматического управления памятью (известной как сборщик мусора); объекты никогда не освобождаются явно. Java Virtual Machine не предполагает какой-либо конкретный тип системы автоматического управления памятью, и метод управления памятью может быть выбран в соответствии с системными требованиями разработчика. Heap может иметь фиксированный размер или может быть расширен по мере необходимости вычислений и может быть сжат, если больший Heap становится ненужным. Память для Heap не обязательно должна быть непрерывной.

Реализация Java Virtual Machine может предоставить программисту или пользователю управление начальным размером Heap, а также, если Heap может быть динамически расширен или сжат, управление максимальным и минимальным размером Heap.

Со следующим исключительным условием связан Heap:

Java Virtual Machine имеет method area, который совместно используется всеми потоками Java Virtual Machine. Method Area аналогична области хранения для скомпилированного кода обычного языка или аналогична сегменту «text» в процессе операционной системы. Она хранит структуры на класс, такие как пул констант во время выполнения, данные полей и методов, а также код для методов и конструкторов, включая специальные методы (§2.9), используемые при инициализации классов и экземпляров и инициализации интерфейсов.

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

Реализация Java Virtual Machine может предоставить программисту или пользователю управление начальным размером Method Area, а также, в случае Method Area переменного размера, управление максимальным и минимальным размером Method Area.

Со следующим исключительным условием связана Method Area:

Пул констант во время выполнения — это представление таблицы constant_pool в файле class (§4.4) для каждого класса или интерфейса во время выполнения. Он содержит несколько видов констант, от числовых литералов, известных во время компиляции, до ссылок на методы и поля, которые должны быть разрешены во время выполнения. Пул констант во время выполнения выполняет функцию, аналогичную таблице символов для обычного языка программирования, хотя он содержит более широкий диапазон данных, чем типичная таблица символов.

Каждый пул констант во время выполнения выделяется из Method Area Java Virtual Machine (§2.5.4). Пул констант во время выполнения для класса или интерфейса строится при создании класса или интерфейса (§5.3) Java Virtual Machine.

Со следующим исключительным условием связано построение пула констант во время выполнения для класса или интерфейса:

См. §5 для получения информации о построении пула констант во время выполнения.

Реализация Java Virtual Machine может использовать обычные стеки, разговорно называемые "C-стеками", для поддержки native методов (методы, написанные на языке, отличном от языка программирования Java). Стеки нативных методов также могут использоваться реализацией интерпретатора набора инструкций Java Virtual Machine на языке, таком как C. Реализации Java Virtual Machine, которые не могут загрузить native методы и не полагаются сами на обычные стеки, не обязаны предоставлять стеки нативных методов. Если они предоставляются, стеки нативных методов обычно выделяются на каждый поток при создании каждого потока.

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

Реализация Java Virtual Machine может предоставить программисту или пользователю контроль над начальным размером стеков нативных методов, а также, в случае стеков нативных методов переменного размера, контроль над максимальным и минимальным размерами стека методов.

Следующие исключительные ситуации связаны со стеками нативных методов:

Каждый фрейм (§2.6) содержит массив переменных, известный как его локальные переменные. Длина массива локальных переменных фрейма определяется во время компиляции и предоставляется в двоичном представлении класса или интерфейса вместе с кодом метода, связанного с фреймом (§4.7.3).

Одна локальная переменная может содержать значение типа boolean, byte, char, short, int, float, reference или returnAddress. Пара локальных переменных может содержать значение типа long или double.

Локальные переменные адресуются по индексу. Индекс первой локальной переменной равен нулю. Целое число рассматривается как индекс в массиве локальных переменных только в том случае, если это целое число находится между нулём и размером массива локальных переменных минус единица.

Значение типа long или типа double занимает две последовательные локальные переменные. Такое значение может быть адресовано только с использованием меньшего индекса. Например, значение типа double, хранящееся в массиве локальных переменных по индексу n, фактически занимает локальные переменные с индексами n и n+1; однако, локальную переменную по индексу n+1 нельзя загружать. Она может быть записана. Однако при этом аннулируется содержимое локальной переменной n.

Виртуальная машина Java не требует, чтобы n было чётным. Проще говоря, значения типов long и double не обязаны быть выровнены по 64 битам в массиве локальных переменных. Реализаторы могут самостоятельно выбрать подходящий способ представления таких значений, используя две локальные переменные, зарезервированные для значения.

Виртуальная машина Java использует локальные переменные для передачи параметров при вызове метода. При вызове метода класса любые параметры передаются в последовательные локальные переменные, начиная с локальной переменной 0. При вызове метода экземпляра локальная переменная 0 всегда используется для передачи ссылки на объект, к которому применяется метод экземпляра (this на языке программирования Java). Любые параметры затем передаются в последовательные локальные переменные, начиная с локальной переменной 1.

Каждый фрейм (§2.6) содержит стек, работающий по принципу «последним вошел — первым вышел» (LIFO), известный как его операторный стек. Максимальная глубина операционного стека фрейма определяется во время компиляции и предоставляется вместе с кодом метода, связанного с фреймом (§4.7.3).

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

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

Например, инструкция iadd (§iadd) складывает два значения int. Она требует, чтобы два значения int, которые нужно сложить, были двумя верхними значениями операционного стека, помещёнными туда предыдущими инструкциями. Оба значения int извлекаются из операционного стека. Они складываются, и их сумма помещается обратно в операционный стек. Подвычисления могут быть вложены в операционном стеке, что приводит к значениям, которые могут использоваться в охватывающем вычислении.

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

Значения из операционного стека должны обрабатываться соответствующим их типам образом. Например, нельзя поместить два значения int и затем обрабатывать их как long, или поместить два значения float и затем складывать их с инструкцией iadd. Небольшое количество инструкций виртуальной машины Java (инструкции dup (§dup) и swap (§swap)) оперируют областями данных во время выполнения как сырыми значениями, не учитывая их конкретные типы; эти инструкции определены таким образом, что они не могут использоваться для изменения или разделения отдельных значений. Эти ограничения на манипуляции операционным стеком контролируются проверкой файлов class (§4.10).

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

Каждый фрейм (§2.6) содержит ссылку на пул постоянных значений выполнения (§2.5.5) для типа текущего метода для поддержки динамической ссылки на код метода. Код метода файла class ссылается на вызываемые методы и переменные через символические ссылки. Динамическая ссылка преобразует эти символические ссылки на метод в конкретные ссылки на метод, загружая классы по мере необходимости для разрешения пока ещё неопределённых символов и преобразует обращения к переменным в соответствующие смещения в структурах хранения, связанных с местоположением этих переменных во время выполнения.

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

Вызов метода завершается нормально, если этот вызов не вызывает исключение (§2.10), которое выбрасывается либо напрямую из виртуальной машины Java, либо в результате выполнения явного throw оператора. Если вызов текущего метода завершается нормально, то вызываемому методу может быть возвращено значение. Это происходит, когда вызываемый метод выполняет одну из инструкций возврата (§2.11.8), выбор которой должен быть соответствующим типу возвращаемого значения (если оно есть).

В этом случае текущий фрейм (§2.6) используется для восстановления состояния вызывающего метода, включая его локальные переменные и стек операндов, при этом счётчик команд вызывающего метода увеличивается соответствующим образом, чтобы перейти за инструкцию вызова метода. Затем выполнение продолжается нормально в фрейме вызывающего метода со возвращаемым значением (если оно есть), помещённым в стек операндов этого фрейма.

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

Инструкции загрузки и сохранения передают значения между локальными переменными (§2.6.1) и стеком операндов (§2.6.2) кадра виртуальной машины Java (§2.6):

Инструкции, которые обращаются к полям объектов и элементам массивов (§2.11.5), также передают данные в стек операндов и из него.

Мнемоники инструкций, показанные выше с заключенными в угловые скобки буквами (например, iload_<n>), обозначают семейства инструкций (с членами iload_0, iload_1, iload_2 и iload_3 в случае iload_<n>). Такие семейства инструкций являются специализациями дополнительной универсальной инструкции (iload), которая принимает один операнд. Для специализированных инструкций операнд неявен и не требует хранения или извлечения. Семантика в остальном одинакова (iload_0 означает то же самое, что и iload с операндом 0). Буква между угловыми скобками указывает тип неявного операнда для этого семейства инструкций: для <n> — неотрицательное целое число; для <i> — int; для <l> — long; для <f> — float; и для <d> — double. Формы для типа int используются во многих случаях для выполнения операций над значениями типа byte, char и short (§2.11.1).

Эта нотация для семейств инструкций используется на протяжении всего данного спецификационного документа.

Арифметические инструкции вычисляют результат, который обычно является функцией двух значений в стеке операндов, помещая результат обратно в стек операндов. Существует два основных вида арифметических инструкций: те, которые работают со значениями целых чисел, и те, которые работают с плавающей точкой. В каждом из этих видов арифметические инструкции специализируются на числовых типах виртуальной машины Java. Нет прямой поддержки целочисленной арифметики для значений типов byte, short и char (§2.11.1), или для значений типа boolean; эти операции обрабатываются инструкциями, работающими с типом int. Целочисленные и инструкции с плавающей точкой также отличаются по своему поведению при переполнении и делении на ноль. Арифметические инструкции следующие:

Семантика операторов языка программирования Java над целыми и значениями с плавающей точкой (JLS §4.2.2, JLS §4.2.4) напрямую поддерживается семантикой набора инструкций виртуальной машины Java.

Виртуальная машина Java не указывает переполнение во время операций с целочисленными типами данных. Единственными целочисленными операциями, которые могут вызвать исключение, являются целочисленные инструкции деления (idiv и ldiv) и целочисленные инструкции остатка от деления (irem и lrem), которые вызывают исключение ArithmeticException, если делитель равен нулю.

Операции виртуальной машины Java с числами с плавающей точкой ведут себя в соответствии со спецификацией IEEE 754. В частности, виртуальная машина Java требует полной поддержки long чисел с плавающей точкой IEEE 754 и int, что упрощает доказательство желаемых свойств конкретных численных алгоритмов.

Виртуальная машина Java требует, чтобы арифметические операции с плавающей точкой вели себя так, как если бы каждый оператор с плавающей точкой округлял свой результат с плавающей точкой до точности результата. long результаты должны быть округлены до представимого значения, ближайшего к бесконечно точному результату; если два ближайших представимых значения находятся на одинаковом расстоянии, выбирается то, у которого наименее значимый бит равен нулю. Это стандартный режим округления IEEE 754, известный как режим округления до ближайшего значения.

Виртуальная машина Java использует режим IEEE 754 float при преобразовании значения с плавающей точкой в целое число. Это приводит к усечению числа; любые биты значащей части, которые представляют дробную часть значения операнда, отбрасываются. Режим округления к нулю выбирает в качестве своего результата значение типа, наиболее близкое к, но не больше по величине, чем бесконечно точный результат.

Операторы с плавающей точкой виртуальной машины Java не вызывают исключений во время выполнения (не следует путать с исключениями с плавающей точкой IEEE 754). Операция, которая переполняется, производит бесконечность со знаком, операция, которая недополняется, производит значение с нормализованным значением или нуль со знаком, а операция, у которой нет математически определенного результата, производит NaN. Все числовые операции с NaN в качестве операнда производят NaN в качестве результата.

Сравнения значений типа long (lcmp) выполняют сравнение со знаком. Сравнения значений с плавающей точкой (dcmpg, dcmpl, fcmpg, fcmpl) выполняются с использованием небезопасных сравнений IEEE 754.

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

Виртуальная машина Java напрямую поддерживает следующие расширяющие числовые преобразования:

Инструкции расширяющих числовых преобразований — это i2l, i2f, i2d, l2f, l2d и f2d. Мнемоники для этих команд очевидны, учитывая соглашения об именовании для типизированных инструкций и использование 2 для обозначения «в». Например, инструкция i2d преобразует значение типа int в значение типа double. Расширяющие числовые преобразования не теряют информацию о величине числового значения. Действительно, преобразования, расширяющие от int к long и int к double, вообще не теряют никакой информации; числовое значение сохраняется точно. Преобразования, расширяющие от float к double, которые являются FP-строгими (§2.8.2), также сохраняют числовое значение точно; однако такие преобразования, которые не являются FP-строгими, могут потерять информацию о величине преобразованного значения.

Преобразование значения типа int или long в float или значения типа long в double может привести к потере точности, то есть может привести к потере некоторых младших битов значения; полученное значение с плавающей точкой является правильно округленным значением целочисленного значения, используя режим округления IEEE 754 до ближайшего значения.

Расширяющее числовое преобразование значения int в long просто расширяет знаковое представление значения int со знаком в формате большего размера. Расширяющее числовое преобразование значения char в целочисленный тип нулевое расширение представления значения char для заполнения формата большего размера.

Несмотря на то, что потеря точности может произойти, расширяющие числовые преобразования никогда не заставят виртуальную машину Java выбросить исключение во время выполнения (не следует путать с исключением IEEE 754 с плавающей точкой).

Обратите внимание, что расширяющие числовые преобразования не существуют от целочисленных типов byte, char и short к типу int. Как отмечается в §2.11.1, значения типа byte, char и short неявно расширяются до типа int, что делает эти преобразования неявными.

Виртуальная машина Java также напрямую поддерживает следующие сужающие числовые преобразования:

Инструкции сужающих числовых преобразований — это i2b, i2c, i2s, l2i, f2i, f2l, d2i, d2l и d2f. Сужающее числовое преобразование может привести к значению с другим знаком, другой величиной или обоим; оно может тем самым потерять точность.

Сужающее числовое преобразование значения int или long в целочисленный тип T просто отбрасывает все, кроме N младших разрядов, где N — количество битов, используемых для представления типа T. Это может привести к тому, что полученное значение не будет иметь тот же знак, что и входное значение.

При сужающем числовом преобразовании значения с плавающей точкой в целочисленный тип T, где T — либо int, либо long, значение с плавающей точкой преобразуется следующим образом:

Сужающее числовое преобразование из double в float ведет себя в соответствии с IEEE 754. Результат правильно округляется с использованием режима округления IEEE 754 до ближайшего значения. Значение, слишком маленькое, чтобы быть представленным как float, преобразуется в положительный или отрицательный ноль типа float; значение, слишком большое, чтобы быть представленным как float, преобразуется в положительную или отрицательную бесконечность. double NaN всегда преобразуется в float NaN.

Несмотря на то, что переполнение, недополнение или потеря точности могут произойти, сужающие преобразования между числовыми типами никогда не заставят виртуальную машину Java выбросить исключение во время выполнения (не следует путать с исключением IEEE 754 с плавающей точкой).

Хотя классы экземпляров и массивы являются объектами, виртуальная машина Java создает и обрабатывает классы экземпляров и массивы с использованием отдельных наборов инструкций:

Для непосредственного управления стеком операндов предоставляется ряд команд: pop, pop2, dup, dup2, dup_x1, dup2_x1, dup_x2, dup2_x2, swap.

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

У виртуальной машины Java есть отдельные наборы команд, которые условно переходят по результатам сравнения данных типов int и reference. Она также имеет отдельные условные команды перехода, которые проверяют на null, и поэтому не требуется указывать конкретное значение для null (§2.4).

Условные переходы по результатам сравнения данных типов boolean, byte, char и short выполняются с использованием команд сравнения int (§2.11.1). Условный переход по результатам сравнения данных типов long, float или double инициируется командой, которая сравнивает данные и производит int результат сравнения (§2.11.3). Последующая команда сравнения int проверяет этот результат и выполняет условный переход. Благодаря акценту на int сравнениях, виртуальная машина Java предоставляет богатый набор инструкций условного перехода для типа int.

Все int условные команды передачи управления выполняют сравнения со знаком.

Следующие пять команд вызывают методы:

Команды возврата методов, различающиеся по типу возвращаемого значения, это ireturn (используется для возврата значений типа boolean, byte, char, short или int), lreturn, freturn, dreturn и areturn. Кроме того, команда return используется для возврата из методов, объявленных как void, методов инициализации экземпляров и методов инициализации классов или интерфейсов.

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

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

Синхронизация на уровне метода выполняется неявно, как часть вызова и возврата метода (§2.11.8). Метод synchronized обозначается в структуре method_info пула постоянных значений во время выполнения (§4.6) флагом ACC_SYNCHRONIZED, который проверяется инструкциями вызова метода. При вызове метода, для которого установлен ACC_SYNCHRONIZED, выполняющий поток входит в монитор, вызывает сам метод и выходит из монитора, независимо от того, завершился ли вызов метода нормально или прерванно. В течение времени, пока выполняющий поток владеет монитором, никакой другой поток не может в него войти. Если во время вызова метода synchronized возникает исключение, и метод synchronized не обрабатывает это исключение, монитор для метода автоматически покидается перед повторной передачей исключения из метода synchronized.

Синхронизация последовательностей инструкций обычно используется для кодирования блока synchronized языка программирования Java. Виртуальная машина Java предоставляет инструкции monitorenter и monitorexit для поддержки таких языковых конструкций. Правильная реализация блоков synchronized требует сотрудничества компилятора, нацеленного на виртуальную машину Java (§3.14).

Структурированное блокирование — это ситуация, когда во время вызова метода каждое завершение работы с заданным монитором соответствует предшествующему входу в этот монитор. Поскольку нет гарантии, что весь код, переданный виртуальной машине Java, будет выполнять структурированное блокирование, реализации виртуальной машины Java могут, но не обязаны, обеспечивать соблюдение следующих двух правил, гарантирующих структурированное блокирование. Пусть T — поток, а M — монитор. Тогда:

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