Интерфейс MemorySegment

public sealed interface MemorySegment

Сегмент памяти предоставляет доступ к непрерывной области памяти.

Существуют два типа сегментов памяти:

Сегмент кучи опирается на и предоставляет доступ к области памяти внутри кучи Java (область "в куче").
Сегмент нативного типа опирается на и предоставляет доступ к области памяти вне кучи Java (область "вне кучи").

Сегменты кучи можно получить, вызвав один из методов-фабрик ofArray(int[]). Эти методы возвращают сегмент памяти, опирающийся на область в куче, содержащую указанный массив Java.

Сегменты нативного типа можно получить, вызвав один из методов-фабрик Arena.allocate(long, long), которые возвращают сегмент памяти, опирающийся на только что выделенную область вне кучи заданного размера и выровненную по заданному ограничению выравнивания. В качестве альтернативы, сегменты нативного типа можно получить, mapping файл в новую область вне кучи (в некоторых системах эта операция иногда называется mmap). Полученные таким образом сегменты называются отображенными сегментами, и их содержимое может быть сохранено и загружено в и из файла отображаемой памяти.

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

Характеристики сегментов памяти

Каждый сегмент памяти имеет адрес, выраженный как long значение. Природа адреса сегмента зависит от типа сегмента:

Адрес сегмента кучи не является физическим адресом, а скорее смещением в области памяти, которая поддерживает сегмент. Эта область находится в куче Java, поэтому сборка мусора может привести к перемещению области в физической памяти со временем, но это не отображается клиентам API MemorySegment, которые видят стабильный виртуализованный адрес для сегмента кучи, поддерживаемого областью. У сегмента кучи, полученного из одного из методов-фабрик ofArray(int[]), адрес равен нулю.
Адрес сегмента нативного типа (включая отображенные сегменты) обозначает физический адрес области памяти, которая поддерживает сегмент.

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

Каждый сегмент памяти имеет размер. Размер сегмента кучи определяется из массива Java, из которого он получен. Этот размер предсказуем во всех реализациях Java. Размер сегмента нативного типа либо явно передаётся (как в Arena.allocate(long, long)), либо определяется из MemoryLayout (как в SegmentAllocator.allocate(MemoryLayout)). Размер сегмента памяти обычно является положительным числом, но может быть нулевым, но никогда отрицательным.

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

Каждый сегмент памяти связан с объёмом. Это гарантирует, что операции доступа к сегменту памяти не могут выполняться, когда область памяти, которая поддерживает сегмент памяти, больше недоступна (например, после того, как область, связанная с доступным сегментом памяти, больше не жива). То есть, сегмент памяти имеет временные границы.

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

Доступ к сегментам памяти

Сегмент памяти можно читать или записывать с помощью различных операций доступа, предоставляемых в этом классе (например, get(ValueLayout.OfInt, long)). Каждая операция доступа принимает размер и форму значения и смещение, выраженное в байтах. Например, чтобы прочитать int из сегмента, используя стандартную кодировку, можно использовать следующий код:

MemorySegment segment = ...
int value = segment.get(ValueLayout.JAVA_INT, 0);

Если значение, которое нужно прочитать, хранится в памяти с использованием кодировки big-endian, операция доступа может быть выражена следующим образом:

int value = segment.get(ValueLayout.JAVA_INT.withOrder(BIG_ENDIAN), 0);

Операции доступа к сегментам памяти реализуются с помощью var-обработчиков. Метод ValueLayout.varHandle() можно использовать для получения var-обработчика, который можно использовать для получения/установки значений, представленных заданным размером значения в сегменте памяти по заданному смещению:

VarHandle intAtOffsetHandle = ValueLayout.JAVA_INT.varHandle(); // (MemorySegment, long)
int value = (int) intAtOffsetHandle.get(segment, 10L);          // segment.get(ValueLayout.JAVA_INT, 10L)

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

VarHandle intAtOffsetAndIndexHandle =
        ValueLayout.JAVA_INT.arrayElementVarHandle();             // (MemorySegment, long, long)
int value = (int) intAtOffsetAndIndexHandle.get(segment, 2L, 3L); // segment.get(ValueLayout.JAVA_INT, 2L + (3L * 4L))

Клиенты также могут опустить параметр базового смещения, чтобы упростить выражение доступа. Это можно использовать для реализации операций доступа, таких как getAtIndex(OfInt, long):

VarHandle intAtIndexHandle =
        MethodHandles.insertCoordinates(intAtOffsetAndIndexHandle, 1, 0L); // (MemorySegment, long)
int value = (int) intAtIndexHandle.get(segment, 3L);                       // segment.getAtIndex(ValueLayout.JAVA_INT, 3L);

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

Выделение сегментов памяти

Сегменты памяти поддерживают выделение. Выделение сегмента памяти возвращает новый сегмент памяти, который опирается на ту же область памяти, что и исходный. Адрес выделенного сегмента определяется из адреса исходного сегмента путём добавления смещения (выраженного в байтах). Размер выделенного сегмента либо выводится неявно (вычитанием указанного смещения из размера исходного сегмента), либо предоставляется явно. Другими словами, выделенный сегмент имеет более строгие пространственные границы, чем исходный сегмент:

 Arena arena = ...
 MemorySegment segment = arena.allocate(100);
 MemorySegment slice = segment.asSlice(50, 10);
 slice.get(ValueLayout.JAVA_INT, 20); // Out of bounds!
 arena.close();
 slice.get(ValueLayout.JAVA_INT, 0); // Already closed!

Вышеприведённый код создаёт сегмент нативного типа длиной 100 байт; затем он создаёт выделение, которое начинается со смещения 50 от segment, и имеет длину 10 байт. То есть адрес slice составляет segment.address() + 50, а его размер — 10. В результате попытка чтения значения int со смещением 20 в сегменте slice приведёт к исключению. Временные границы исходного сегмента наследуются его выделениями; то есть, когда область, связанная с segment, больше не жива, slice также станет недоступным.

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

 try (Arena arena = Arena.ofShared()) {
     SequenceLayout SEQUENCE_LAYOUT = MemoryLayout.sequenceLayout(1024, ValueLayout.JAVA_INT);
     MemorySegment segment = arena.allocate(SEQUENCE_LAYOUT);
     int sum = segment.elements(ValueLayout.JAVA_INT).parallel()
                      .mapToInt(s -> s.get(ValueLayout.JAVA_INT, 0))
                      .sum();
 }

Выравнивание

Операции доступа к сегменту памяти ограничены не только пространственными и временными границами сегмента, но и ограничением выравнивания размера значения, указанного в операции. Операция доступа может получить доступ только к тем смещениям в сегменте, которые обозначают адреса в физической памяти, которые выровнены в соответствии с макетом. Адрес в физической памяти выровнен в соответствии с макетом, если адрес является целым кратным ограничения выравнивания макета. Например, адрес 1000 выровнен по ограничению выравнивания 8 байт (поскольку 1000 является целым кратным 8) и по ограничению выравнивания 4 байта и по ограничению выравнивания 2 байта; напротив, адрес 1004 выровнен по ограничению выравнивания 4 байта и по ограничению выравнивания 2 байта, но не по ограничению выравнивания 8 байт. Операции доступа обязаны соблюдать выравнивание, потому что это может повлиять на производительность операций доступа и может также определить, какие операции доступа доступны по данному физическому адресу. Например, атомарные операции доступа с использованием VarHandle разрешены только по выровненным адресам. Кроме того, выравнивание применяется к операции доступа, независимо от того, является ли доступный сегмент сегментом нативного типа или сегментом кучи.

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

boolean isAligned(MemorySegment segment, long offset, MemoryLayout layout) {
  return ((segment.address() + offset) % layout.byteAlignment()) == 0;
}

Например:

Доступ к нативному сегменту с адресом 1000 возможен по смещениям 0, 8, 16, 24 и т. д. из-за ограничения выравнивания в 8 байт, так как целевые адреса (1000, 1008, 1016, 1024) выровнены по 8 байтам. Доступ по смещениям 1-7 или 9-15 или 17-23 запрещён, так как целевые адреса не будут выровнены по 8 байтам.
Доступ к нативному сегменту с адресом 1000 возможен по смещениям 0, 4, 8, 12 и т. д. из-за ограничения выравнивания в 4 байта, так как целевые адреса (1000, 1004, 1008, 1012) выровнены по 4 байтам. Доступ по смещениям 1-3 или 5-7 или 9-11 запрещён, так как целевые адреса не будут выровнены по 4 байтам.
Доступ к нативному сегменту с адресом 1000 возможен по смещениям 0, 2, 4, 6 и т. д. из-за ограничения выравнивания в 2 байта, так как целевые адреса (1000, 1002, 1004, 1006) выровнены по 2 байтам. Доступ по смещениям 1 или 3 или 5 запрещён, так как целевые адреса не будут выровнены по 2 байтам.
Доступ к нативному сегменту с адресом 1004 возможен по смещениям 0, 4, 8, 12 и т. д. с ограничением выравнивания в 4 байта и по смещениям 0, 2, 4, 6 и т. д. с ограничением выравнивания в 2 байта. С ограничением выравнивания в 8 байт, доступ возможен по смещениям 4, 12, 20, 28 и т. д.
Доступ к нативному сегменту с адресом 1006 возможен по смещениям 0, 2, 4, 6 и т. д. с ограничением выравнивания в 2 байта. С ограничением выравнивания в 4 байта, доступ возможен по смещениям 2, 6, 10, 14 и т. д. С ограничением выравнивания в 8 байт, доступ возможен по смещениям 2, 10, 18, 26 и т. д.
Доступ к нативному сегменту с адресом 1007 возможен по смещениям 0, 1, 2, 3 и т. д. с ограничением выравнивания в 1 байт. С ограничением выравнивания в 2 байта, доступ возможен по смещениям 1, 3, 5, 7 и т. д. С ограничением выравнивания в 4 байта, доступ возможен по смещениям 1, 5, 9, 13 и т. д. С ограничением выравнивания в 8 байт, доступ возможен по смещениям 1, 9, 17, 25 и т. д.

Ограничение выравнивания, используемое для доступа к сегменту, обычно определяется структурой данных, хранящейся в сегменте. Например, если программист хочет сохранить последовательность значений по 8 байт в нативном сегменте, то сегмент должен быть выделен с ограничением выравнивания в 8 байт, либо через Arena.allocate(long, long), либо через SegmentAllocator.allocate(MemoryLayout). Эти фабрики гарантируют, что начальный адрес области памяти вне кучи, поддерживающей возвращённый сегмент, выровнен по 8 байтам. После этого программист может получить доступ к сегменту по смещениям, которые его интересуют — 0, 8, 16, 24 и т. д. — зная, что каждый такой доступ выровнен.

Если доступный сегмент — сегмент кучи, то определение того, выровнен ли доступ, более сложно. Адрес сегмента в физической памяти неизвестен и даже не фиксирован (он может измениться при перемещении сегмента во время сбора мусора). Это означает, что адрес нельзя комбинировать со смещением, чтобы определить целевой адрес в физической памяти. Поскольку ограничение выравнивания *всегда* относится к выравниванию адресов в физической памяти, принципиально невозможно определить, выровнено ли какое-либо смещение в сегменте кучи. Например, предположим, что программист выбирает ограничение выравнивания в 8 байт и пытается получить доступ к смещению 16 в сегменте кучи. Если адрес сегмента кучи 0 соответствует физическому адресу 1000, то целевой адрес (1016) будет выровнен, но если адрес 0 соответствует физическому адресу 1004, то целевой адрес (1020) не будет выровнен. Нежелательно разрешать доступ к целевым адресам, которые выровнены согласно выбранному программистом ограничению выравнивания, но могут не быть предсказуемо выровнены в физической памяти (например, из-за особенностей платформы и/или поведения сбора мусора).

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

Начальный физический адрес массива short[] будет выровнен по 2 байтам (например, 1006), так что последующие элементы типа short будут находиться по адресам, выровненным по 2 байтам (например, 1006, 1008, 1010, 1012 и т. д.). Сегмент кучи, поддерживаемый массивом short[], можно получить доступ по смещениям 0, 2, 4, 6 и т. д. с ограничением выравнивания в 2 байта. К сегменту нельзя получить доступ ни по какому смещению с ограничением выравнивания в 4 байта, потому что нет гарантии, что целевой адрес будет выровнен по 4 байтам, например, смещение 0 будет соответствовать физическому адресу 1006, а смещение 1 — физическому адресу 1007. Аналогично, к сегменту нельзя получить доступ ни по какому смещению с ограничением выравнивания в 8 байт, потому что нет гарантии, что целевой адрес будет выровнен по 8 байтам, например, смещение 2 будет соответствовать физическому адресу 1008, а смещение 4 — физическому адресу 1010.
Начальный физический адрес массива long[] будет выровнен по 8 байтам (например, 1000), так что последующие элементы типа long будут находиться по адресам, выровненным по 8 байтам (например, 1000, 1008, 1016, 1024 и т. д.). Сегмент кучи, поддерживаемый массивом long[], можно получить доступ по смещениям 0, 8, 16, 24 и т. д. с ограничением выравнивания в 8 байт. Кроме того, к сегменту можно получить доступ по смещениям 0, 4, 8, 12 и т. д. с ограничением выравнивания в 4 байта, потому что целевые адреса (1000, 1004, 1008, 1012) выровнены по 4 байтам. И к сегменту можно получить доступ по смещениям 0, 2, 4, 6 и т. д. с ограничением выравнивания в 2 байта, потому что целевые адреса (например, 1000, 1002, 1004, 1006) выровнены по 2 байтам.

Другими словами, сегменты кучи имеют *максимальное* выравнивание, которое определяется размером элементов массива Java, поддерживающего сегмент, как показано в следующей таблице:

Максимальное выравнивание сегментов кучи

Тип массива (поддерживающей области) Максимальное поддерживаемое выравнивание (в байтах)

boolean[] ValueLayout.JAVA_BOOLEAN.byteAlignment()

byte[] ValueLayout.JAVA_BYTE.byteAlignment()

char[] ValueLayout.JAVA_CHAR.byteAlignment()

short[] ValueLayout.JAVA_SHORT.byteAlignment()

int[] ValueLayout.JAVA_INT.byteAlignment()

float[] ValueLayout.JAVA_FLOAT.byteAlignment()

long[] ValueLayout.JAVA_LONG.byteAlignment()

double[] ValueLayout.JAVA_DOUBLE.byteAlignment()

Максимальное выравнивание сегментов кучи
Тип массива (поддерживающей области)	Максимальное поддерживаемое выравнивание (в байтах)
`boolean[]`	`ValueLayout.JAVA_BOOLEAN.byteAlignment()`
`byte[]`	`ValueLayout.JAVA_BYTE.byteAlignment()`
`char[]`	`ValueLayout.JAVA_CHAR.byteAlignment()`
`short[]`	`ValueLayout.JAVA_SHORT.byteAlignment()`
`int[]`	`ValueLayout.JAVA_INT.byteAlignment()`
`float[]`	`ValueLayout.JAVA_FLOAT.byteAlignment()`
`long[]`	`ValueLayout.JAVA_LONG.byteAlignment()`
`double[]`	`ValueLayout.JAVA_DOUBLE.byteAlignment()`

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

MemorySegment byteSegment = MemorySegment.ofArray(new byte[10]);
byteSegment.get(ValueLayout.JAVA_INT, 0); // fails: ValueLayout.JAVA_INT.byteAlignment() > ValueLayout.JAVA_BYTE.byteAlignment()

В таких случаях у клиентов есть два варианта. Они могут использовать сегмент кучи, поддерживаемый другим типом массива (например, long[]), способным поддерживать большее максимальное выравнивание. Более конкретно, максимальное выравнивание, связанное с long[], установлено в ValueLayout.JAVA_LONG.byteAlignment(), что составляет 8 байт:

MemorySegment longSegment = MemorySegment.ofArray(new long[10]);
longSegment.get(ValueLayout.JAVA_INT, 0); // ok: ValueLayout.JAVA_INT.byteAlignment() <= ValueLayout.JAVA_LONG.byteAlignment()

В качестве альтернативы они могут вызвать операцию доступа с *невыровненным макетом*. Все константы невыровненных макетов (например, ValueLayout.JAVA_INT_UNALIGNED) имеют ограничение выравнивания, установленное в 1:

MemorySegment byteSegment = MemorySegment.ofArray(new byte[10]);
byteSegment.get(ValueLayout.JAVA_INT_UNALIGNED, 0); // ok: ValueLayout.JAVA_INT_UNALIGNED.byteAlignment() == ValueLayout.JAVA_BYTE.byteAlignment()

Клиенты могут использовать метод maxByteAlignment() для проверки того, поддерживает ли сегмент памяти ограничение выравнивания макета памяти, как показано ниже:

MemoryLayout layout = ...
MemorySegment segment = ...
boolean isAligned = segment.maxByteAlignment() >= layout.byteAlignment();

Сегменты памяти нулевой длины

При работе с внешними функциями эти функции обычно выделяют область памяти и возвращают указатель на эту область. Моделирование области памяти с помощью сегмента памяти затруднено, так как среда выполнения Java не имеет представления о размере области. Известен только адрес начала области, хранящийся в указателе. Например, функция C с типом возвращаемого значения char* может вернуть указатель на область, содержащую одно значение char, или на область, содержащую массив значений char, где размер массива может быть предоставлен в отдельном параметре. Размер массива не очевиден для кода, вызывающего внешнюю функцию и надеющегося использовать её результат. Помимо отсутствия представления о размере области памяти, поддерживающей указатель, возвращённый внешней функцией, среда выполнения также не имеет представления о предполагаемом сроке жизни этой области памяти со стороны внешней функции, которая её выделила.

API MemorySegment использует *сегменты памяти нулевой длины* для представления:

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

Адрес сегмента нулевой длины — это адрес, хранящийся в указателе. Пространственные и временные границы сегмента нулевой длины следующие:

Размер сегмента равен нулю. Любая попытка получить доступ к этим сегментам завершится ошибкой с IndexOutOfBoundsException. Это ключевая функция безопасности: так как эти сегменты связаны с областью памяти, размер которой неизвестен, любые операции доступа, связанные с этими сегментами, не могут быть проверены. По сути, сегмент памяти нулевой длины *обрамляет* адрес, и он не может использоваться без явного намерения (см. ниже);
Сегмент связан со глобальной областью. Таким образом, хотя к сегментам памяти нулевой длины нельзя получить прямой доступ, их можно передать другим внешним функциям, принимающим указатели.

Для демонстрации работы с сегментами памяти нулевой длины рассмотрим случай, когда клиент хочет прочитать указатель из некоторого сегмента памяти. Это можно сделать с помощью метода доступа get(AddressLayout, long). Этот метод принимает макет адреса address layout (например, ValueLayout.ADDRESS), макет указателя, который нужно прочитать. Например, на 64-битной платформе размер макета адреса составляет 8 байт. Операция доступа также принимает смещение, выраженное в байтах, которое указывает позицию (относительно начала сегмента памяти), в которой хранится указатель. Операция доступа возвращает сегмент памяти нулевой длины, поддерживаемый областью памяти, начальный адрес которой является 64-битным значением, считанным по указанному смещению.

Возвращаемый сегмент памяти нулевой длины не может быть напрямую доступен клиенту: так как размер сегмента равен нулю, любая операция доступа приведет к обращению за пределы границ. Вместо этого клиент должен, неосторожно, назначить новые пространственные границы сегменту памяти нулевой длины. Это можно сделать с помощью метода reinterpret(long)^{ОГРАНИЧЕННО}, как показано ниже:

 MemorySegment z = segment.get(ValueLayout.ADDRESS, ...);   // size = 0
 MemorySegment ptr = z.reinterpret(16);                     // size = 16
 int x = ptr.getAtIndex(ValueLayout.JAVA_INT, 3);           // ok

В некоторых случаях клиенту может потребоваться дополнительно назначить новые временные границы сегменту памяти нулевой длины. Это можно сделать с помощью метода reinterpret(long, Arena, Consumer)^{ОГРАНИЧЕННО}, который возвращает новый сегмент с желаемым размером и теми же временными границами, что и у предоставленной арены:

 MemorySegment ptr = null;
 try (Arena arena = Arena.ofConfined()) {
       MemorySegment z = segment.get(ValueLayout.ADDRESS, ...);    // size = 0, scope = always alive
       ptr = z.reinterpret(16, arena, null);                       // size = 16, scope = arena.scope()
       int x = ptr.getAtIndex(ValueLayout.JAVA_INT, 3);            // ok
 }
 int x = ptr.getAtIndex(ValueLayout.JAVA_INT, 3);                  // throws IllegalStateException

В качестве альтернативы, если размер области памяти, поддерживающей сегмент памяти нулевой длины, известен статически, клиент может наложить целевой макет^{ОГРАНИЧЕННО} на макет адреса, используемый при чтении указателя. Затем целевой макет используется для динамического расширения размера сегмента памяти, возвращаемого операцией доступа, таким образом, что размер сегмента совпадает с размером целевого макета. Другими словами, возвращаемый сегмент больше не является сегментом памяти нулевой длины, и указатель, который он представляет, может быть непосредственно обращен к нему:

 AddressLayout intArrPtrLayout = ValueLayout.ADDRESS.withTargetLayout(
         MemoryLayout.sequenceLayout(4, ValueLayout.JAVA_INT)); // layout for int (*ptr)[4]
 MemorySegment ptr = segment.get(intArrPtrLayout, ...);         // size = 16
 int x = ptr.getAtIndex(ValueLayout.JAVA_INT, 3);               // ok

Все методы, которые могут использоваться для управления сегментами памяти нулевой длины (reinterpret(long)^{ОГРАНИЧЕННО}, reinterpret(Arena, Consumer)^{ОГРАНИЧЕННО}, reinterpret(long, Arena, Consumer)^{ОГРАНИЧЕННО} и AddressLayout.withTargetLayout(MemoryLayout)^{ОГРАНИЧЕННО}) являются ограниченными методами и должны использоваться с осторожностью: назначение сегменту неправильных пространственных и/или временных границ может привести к сбою виртуальной машины при попытке доступа к сегменту памяти.

Требования к реализации:: Реализации этого интерфейса неизменяемы, потокобезопасны и базируются на значении.
С момента:: 22

Краткое описание вложенных классов

Модификатор и тип	Интерфейс	Описание
`static interface`	`MemorySegment.Scope`	Область моделирует срок службы всех сегментов памяти, связанных с ней.

Краткое описание полей

Модификатор и тип	Поле	Описание
`static final MemorySegment`	`NULL`	Сегмент нулевой длины, моделирующий `NULL` адрес.

Краткое описание методов

Модификатор и тип	Метод	Описание
`long`	`address()`	Возвращает адрес этого сегмента памяти.
`ByteBuffer`	`asByteBuffer()`	Оборачивает этот сегмент в `ByteBuffer`.
`Optional<MemorySegment>`	`asOverlappingSlice(MemorySegment other)`	Возвращает срез этого сегмента, являющийся перекрытием между этим и предоставленным сегментом.
`MemorySegment`	`asReadOnly()`	Возвращает чтение-только представление этого сегмента.
`MemorySegment`	`asSlice(long offset)`	Возвращает срез этого сегмента памяти по указанному смещению.
`MemorySegment`	`asSlice(long offset, long newSize)`	Возвращает срез этого сегмента памяти по указанному смещению.
`MemorySegment`	`asSlice(long offset, long newSize, long byteAlignment)`	Возвращает срез этого сегмента памяти по указанному смещению с указанным ограничением выравнивания.
`MemorySegment`	`asSlice(long offset, MemoryLayout layout)`	Возвращает срез этого сегмента памяти с заданной структурой, по указанному смещению.
`long`	`byteSize()`	Возвращает размер (в байтах) этого сегмента памяти.
`static void`	`copy(MemorySegment srcSegment, long srcOffset, MemorySegment dstSegment, long dstOffset, long bytes)`	Выполняет массивную копию из исходного сегмента в целевой сегмент.
`static void`	`copy(MemorySegment srcSegment, ValueLayout srcElementLayout, long srcOffset, MemorySegment dstSegment, ValueLayout dstElementLayout, long dstOffset, long elementCount)`	Выполняет массивную копию из исходного сегмента в целевой сегмент.
`static void`	`copy(MemorySegment srcSegment, ValueLayout srcLayout, long srcOffset, Object dstArray, int dstIndex, int elementCount)`	Копирует определенное количество элементов из исходного сегмента памяти в целевой массив.
`static void`	`copy(Object srcArray, int srcIndex, MemorySegment dstSegment, ValueLayout dstLayout, long dstOffset, int elementCount)`	Копирует определенное количество элементов из исходного массива в целевой сегмент памяти.
`MemorySegment`	`copyFrom(MemorySegment src)`	Выполняет массивную копию из заданного исходного сегмента в этот сегмент.
`Stream<MemorySegment>`	`elements(MemoryLayout elementLayout)`	Возвращает последовательный `Stream` по непересекающимся срезам (размер которых соответствует заданной структуре) в этом сегменте.
`boolean`	`equals(Object that)`	Сравнивает указанный объект с этим сегментом памяти на равенство.
`MemorySegment`	`fill(byte value)`	Заполняет содержимое этого сегмента памяти заданным значением.
`void`	`force()`	Принудительно записывает все изменения, внесенные в содержимое этого сопоставленного сегмента, на устройство хранения, описанное дескриптором файла сопоставленного сегмента.
`MemorySegment`	`get(AddressLayout layout, long offset)`	Читает адрес из этого сегмента по указанному смещению со значением заданной структуры.
`boolean`	`get(ValueLayout.OfBoolean layout, long offset)`	Читает булево значение из этого сегмента по указанному смещению со значением заданной структуры.
`byte`	`get(ValueLayout.OfByte layout, long offset)`	Читает байт из этого сегмента по указанному смещению со значением заданной структуры.
`char`	`get(ValueLayout.OfChar layout, long offset)`	Читает символ из этого сегмента по указанному смещению со значением заданной структуры.
`double`	`get(ValueLayout.OfDouble layout, long offset)`	Читает двойную точность из этого сегмента по указанному смещению со значением заданной структуры.
`float`	`get(ValueLayout.OfFloat layout, long offset)`	Читает одинарную точность из этого сегмента по указанному смещению со значением заданной структуры.
`int`	`get(ValueLayout.OfInt layout, long offset)`	Читает целое значение из этого сегмента по указанному смещению со значением заданной структуры.
`long`	`get(ValueLayout.OfLong layout, long offset)`	Читает длинное целое значение из этого сегмента по указанному смещению со значением заданной структуры.
`short`	`get(ValueLayout.OfShort layout, long offset)`	Читает короткое целое значение из этого сегмента по указанному смещению со значением заданной структуры.
`MemorySegment`	`getAtIndex(AddressLayout layout, long index)`	Читает адрес из этого сегмента по заданному индексу, масштабированному по размеру заданной структуры.
`boolean`	`getAtIndex(ValueLayout.OfBoolean layout, long index)`	Читает булево значение из этого сегмента по заданному индексу, масштабированному по размеру заданной структуры.
`byte`	`getAtIndex(ValueLayout.OfByte layout, long index)`	Читает байт из этого сегмента по заданному индексу, масштабированному по размеру заданной структуры.
`char`	`getAtIndex(ValueLayout.OfChar layout, long index)`	Читает символ из этого сегмента по заданному индексу, масштабированному по размеру заданной структуры.
`double`	`getAtIndex(ValueLayout.OfDouble layout, long index)`	Читает двойную точность из этого сегмента по заданному индексу, масштабированному по размеру заданной структуры.
`float`	`getAtIndex(ValueLayout.OfFloat layout, long index)`	Читает одинарную точность из этого сегмента по заданному индексу, масштабированному по размеру заданной структуры.
`int`	`getAtIndex(ValueLayout.OfInt layout, long index)`	Читает целое значение из этого сегмента по заданному индексу, масштабированному по размеру заданной структуры.
`long`	`getAtIndex(ValueLayout.OfLong layout, long index)`	Читает длинное целое значение из этого сегмента по заданному индексу, масштабированному по размеру заданной структуры.
`short`	`getAtIndex(ValueLayout.OfShort layout, long index)`	Читает короткое целое значение из этого сегмента по заданному индексу, масштабированному по размеру заданной структуры.
`String`	`getString(long offset)`	Читает строку с нулевым окончанием из этого сегмента по указанному смещению, используя кодировку UTF-8.
`String`	`getString(long offset, Charset charset)`	Читает строку с нулевым окончанием из этого сегмента по указанному смещению, используя предоставленную кодировку.
`int`	`hashCode()`	Возвращает хэш-код для этого сегмента памяти.
`Optional<Object>`	`heapBase()`	Возвращает объект Java, хранящийся в куче, которая является основой этого сегмента памяти, если таковой имеется.
`boolean`	`isAccessibleBy(Thread thread)`	Возвращает `true`, если к этому сегменту можно получить доступ из предоставленной нити.
`boolean`	`isLoaded()`	Определяет, находятся ли все содержимое этого сопоставленного сегмента в физической памяти.
`boolean`	`isMapped()`	Возвращает `true`, если этот сегмент является сопоставленным сегментом.
`boolean`	`isNative()`	Возвращает `true`, если этот сегмент является нативным сегментом.
`boolean`	`isReadOnly()`	Возвращает `true`, если этот сегмент является только для чтения.
`void`	`load()`	Загружает содержимое этого сопоставленного сегмента в физическую память.
`long`	`maxByteAlignment()`	Возвращает максимальное выравнивание байтов, связанное с этим сегментом памяти.
`long`	`mismatch(MemorySegment other)`	Находит и возвращает смещение, в байтах, первого несоответствия между этим сегментом и заданным другим сегментом.
`static long`	`mismatch(MemorySegment srcSegment, long srcFromOffset, long srcToOffset, MemorySegment dstSegment, long dstFromOffset, long dstToOffset)`	Находит и возвращает относительное смещение, в байтах, первого несоответствия между исходным и целевым сегментами.
`static MemorySegment`	`ofAddress(long address)`	Создает нативный сегмент нулевой длины из заданного значения адреса.
`static MemorySegment`	`ofArray(byte[] byteArray)`	Создает сегмент кучи, поддерживаемый областью кучевой памяти, которая содержит заданный массив байтов.
`static MemorySegment`	`ofArray(char[] charArray)`	Создает сегмент кучи, поддерживаемый областью кучевой памяти, которая содержит заданный массив символов.
`static MemorySegment`	`ofArray(double[] doubleArray)`	Создает сегмент кучи, поддерживаемый областью кучевой памяти, которая содержит заданный массив двойной точности.
`static MemorySegment`	`ofArray(float[] floatArray)`	Создает сегмент кучи, поддерживаемый областью кучевой памяти, которая содержит заданный массив одинарной точности.
`static MemorySegment`	`ofArray(int[] intArray)`	Создает сегмент кучи, поддерживаемый областью кучевой памяти, которая содержит заданный массив целых чисел.
`static MemorySegment`	`ofArray(long[] longArray)`	Создает сегмент кучи, поддерживаемый областью кучевой памяти, которая содержит заданный массив длинных целых чисел.

`static MemorySegment`	`ofArray(short[] shortArray)`	Создаёт сегмент кучи, поддерживаемый областью кучи памяти, которая хранит заданный короткий массив.
`static MemorySegment`	`ofBuffer(Buffer buffer)`	Создаёт сегмент памяти, поддерживаемый той же областью памяти, что и заданный экземпляр `Buffer`.
`MemorySegment`	`reinterpret(long newSize)`	Ограниченный доступ. Возвращает новый сегмент памяти с тем же адресом и областью видимости, что и этот сегмент, но с указанным размером.
`MemorySegment`	`reinterpret(long newSize, Arena arena, Consumer<MemorySegment> cleanup)`	Ограниченный доступ. Возвращает новый сегмент с тем же адресом, что и этот сегмент, но с указанным размером и областью видимости.
`MemorySegment`	`reinterpret(Arena arena, Consumer<MemorySegment> cleanup)`	Ограниченный доступ. Возвращает новый сегмент памяти с тем же адресом и размером, что и этот сегмент, но с указанной областью видимости.
`MemorySegment.Scope`	`scope()`	Возвращает область видимости, связанную с этим сегментом памяти.
`void`	`set(AddressLayout layout, long offset, MemorySegment value)`	Записывает адрес в этот сегмент по заданному смещению с заданной структурой.
`void`	`set(ValueLayout.OfBoolean layout, long offset, boolean value)`	Записывает булево значение в этот сегмент по заданному смещению с заданной структурой.
`void`	`set(ValueLayout.OfByte layout, long offset, byte value)`	Записывает байт в этот сегмент по заданному смещению с заданной структурой.
`void`	`set(ValueLayout.OfChar layout, long offset, char value)`	Записывает символ в этот сегмент по заданному смещению с заданной структурой.
`void`	`set(ValueLayout.OfDouble layout, long offset, double value)`	Записывает double в этот сегмент по заданному смещению с заданной структурой.
`void`	`set(ValueLayout.OfFloat layout, long offset, float value)`	Записывает float в этот сегмент по заданному смещению с заданной структурой.
`void`	`set(ValueLayout.OfInt layout, long offset, int value)`	Записывает int в этот сегмент по заданному смещению с заданной структурой.
`void`	`set(ValueLayout.OfLong layout, long offset, long value)`	Записывает long в этот сегмент по заданному смещению с заданной структурой.
`void`	`set(ValueLayout.OfShort layout, long offset, short value)`	Записывает short в этот сегмент по заданному смещению с заданной структурой.
`void`	`setAtIndex(AddressLayout layout, long index, MemorySegment value)`	Записывает адрес в этот сегмент по заданному индексу, масштабированному на размер заданной структуры.
`void`	`setAtIndex(ValueLayout.OfBoolean layout, long index, boolean value)`	Записывает булево значение в этот сегмент по заданному индексу, масштабированному на размер заданной структуры.
`void`	`setAtIndex(ValueLayout.OfByte layout, long index, byte value)`	Записывает байт в этот сегмент по заданному индексу, масштабированному на размер заданной структуры.
`void`	`setAtIndex(ValueLayout.OfChar layout, long index, char value)`	Записывает символ в этот сегмент по заданному индексу, масштабированному на размер заданной структуры.
`void`	`setAtIndex(ValueLayout.OfDouble layout, long index, double value)`	Записывает double в этот сегмент по заданному индексу, масштабированному на размер заданной структуры.
`void`	`setAtIndex(ValueLayout.OfFloat layout, long index, float value)`	Записывает float в этот сегмент по заданному индексу, масштабированному на размер заданной структуры.
`void`	`setAtIndex(ValueLayout.OfInt layout, long index, int value)`	Записывает int в этот сегмент по заданному индексу, масштабированному на размер заданной структуры.
`void`	`setAtIndex(ValueLayout.OfLong layout, long index, long value)`	Записывает long в этот сегмент по заданному индексу, масштабированному на размер заданной структуры.
`void`	`setAtIndex(ValueLayout.OfShort layout, long index, short value)`	Записывает short в этот сегмент по заданному индексу, масштабированному на размер заданной структуры.
`void`	`setString(long offset, String str)`	Записывает заданную строку в этот сегмент по заданному смещению, преобразуя её в нуль-терминированную последовательность байтов с использованием кодировки UTF-8.
`void`	`setString(long offset, String str, Charset charset)`	Записывает заданную строку в этот сегмент по заданному смещению, преобразуя её в нуль-терминированную последовательность байтов с использованием заданной кодировки.
`Spliterator<MemorySegment>`	`spliterator(MemoryLayout elementLayout)`	Возвращает итератор для этого сегмента памяти.
`byte[]`	`toArray(ValueLayout.OfByte elementLayout)`	Копирует содержимое этого сегмента памяти в новый массив байтов.
`char[]`	`toArray(ValueLayout.OfChar elementLayout)`	Копирует содержимое этого сегмента памяти в новый массив символов.
`double[]`	`toArray(ValueLayout.OfDouble elementLayout)`	Копирует содержимое этого сегмента памяти в новый массив double.
`float[]`	`toArray(ValueLayout.OfFloat elementLayout)`	Копирует содержимое этого сегмента памяти в новый массив float.
`int[]`	`toArray(ValueLayout.OfInt elementLayout)`	Копирует содержимое этого сегмента памяти в новый массив int.
`long[]`	`toArray(ValueLayout.OfLong elementLayout)`	Копирует содержимое этого сегмента памяти в новый массив long.
`short[]`	`toArray(ValueLayout.OfShort elementLayout)`	Освобождает содержимое этого сопоставленного сегмента из физической памяти.

Подробное описание полей

NULL

static final MemorySegment NULL

Сегмент с длиной 0, моделирующий NULL адрес. Эквивалентно MemorySegment.ofAddress(0L).

Максимальное выравнивание байтов для сегмента NULL составляет 2⁶².

Подробное описание методов

address

long address()

Возвращает адрес этого сегмента памяти.

Примечание API:: При использовании этого метода для передачи адреса сегмента во внешнюю операцию (например, функцию JNI), клиенты должны гарантировать, что сегмент остается доступным в течение всего времени выполнения операции. Отсутствие этого может привести к преждевременному освобождению области памяти, поддерживающей сегмент памяти, в случае, если сегмент был выделен с использованием автоматической области.
Возвращает:: адрес этого сегмента памяти

heapBase

Optional<Object> heapBase()

Возвращает объект Java, хранящийся в области кучи памяти, поддерживающей этот сегмент памяти, если таковой имеется. Например, если этот сегмент памяти — сегмент кучи, созданный с помощью метода-фабрики ofArray(byte[]), этот метод вернёт объект byte[], который использовался для получения сегмента. Этот метод возвращает пустое значение Optional, если сегмент является сегментом родного типа или если этот сегмент только для чтения.

Возвращает:: объект Java, связанный с этим сегментом памяти, если таковой имеется

spliterator

Spliterator<MemorySegment> spliterator(MemoryLayout elementLayout)

Возвращает разделитель для этого сегмента памяти. Возвращаемый разделитель сообщает о характеристиках Spliterator.SIZED, Spliterator.SUBSIZED, Spliterator.IMMUTABLE, Spliterator.NONNULL и Spliterator.ORDERED.

Возвращаемый разделитель разделяет этот сегмент в соответствии с заданной структурой элемента; то есть, если предоставленная структура имеет размер N, то вызов Spliterator.trySplit() приведёт к разделителю, обслуживающему приблизительно S/N элементов (в зависимости от того, чётное ли N), где S — размер этого сегмента. Таким образом, разделение возможно, пока S/N >= 2. Разделитель возвращает сегменты, имеющие тот же жизненный цикл, что и у этого сегмента.

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

Параметры:: elementLayout - структура, используемая для разделения
Возвращает:: разделитель элементов для этого сегмента
Исключения:: IllegalArgumentException - если elementLayout.byteSize() == 0; IllegalArgumentException - если byteSize() % elementLayout.byteSize() != 0; IllegalArgumentException - если elementLayout.byteSize() % elementLayout.byteAlignment() != 0; IllegalArgumentException - если этот сегмент несовместим с ограничением выравнивания в предоставленной структуре.

elements

Stream<MemorySegment> elements(MemoryLayout elementLayout)

Возвращает последовательный Stream по непересекающимся срезам (размер которых соответствует заданной структуре) в этом сегменте. Вызов этого метода эквивалентен следующему коду:

StreamSupport.stream(segment.spliterator(elementLayout), false);

Параметры:: elementLayout - структура, используемая для разделения
Возвращает:: последовательный Stream по непересекающимся срезам в этом сегменте
Исключения:: IllegalArgumentException - если elementLayout.byteSize() == 0; IllegalArgumentException - если byteSize() % elementLayout.byteSize() != 0; IllegalArgumentException - если elementLayout.byteSize() % elementLayout.byteAlignment() != 0; IllegalArgumentException - если этот сегмент несовместим с ограничением выравнивания в предоставленной структуре

scope

MemorySegment.Scope scope()

Возвращает область, связанную с этим сегментом памяти.

Возвращает:: область, связанную с этим сегментом памяти

isAccessibleBy

boolean isAccessibleBy(Thread thread)

Возвращает true, если к этому сегменту можно получить доступ из предоставленного потока.

Параметры:: thread - проверяемый поток
Возвращает:: true, если к этому сегменту можно получить доступ из предоставленного потока

byteSize

long byteSize()

Возвращает размер (в байтах) этого сегмента памяти.

Возвращает:: размер (в байтах) этого сегмента памяти

maxByteAlignment

long maxByteAlignment()

Возвращает максимальное выравнивание байтов, связанное с этим сегментом памяти.

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

Этот метод можно использовать для проверки достаточного выравнивания сегмента с структурой:

MemoryLayout layout = ...
MemorySegment segment = ...
if (segment.maxByteAlignment() < layout.byteAlignment()) {
    // Take action (e.g. throw an Exception)
}

Возвращает:: максимальное выравнивание байтов, связанное с этим сегментом памяти
С:: 23

asSlice

MemorySegment asSlice(long offset, long newSize)

Возвращает срез этого сегмента памяти по заданному смещению. Адрес возвращаемого сегмента — адрес этого сегмента плюс заданное смещение; его размер задаётся аргументом.

Эквивалентно следующему коду:

asSlice(offset, newSize, 1);

Если этот сегмент только для чтения, возвращаемый сегмент также только для чтения.

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

Параметры:

offset - новое смещение начала сегмента (относительно адреса этого сегмента), заданное в байтах

newSize - новый размер сегмента, заданный в байтах

Возвращает:

срез этого сегмента памяти

Исключения:

IndexOutOfBoundsException - если offset < 0, offset > byteSize(), newSize < 0 или newSize > byteSize() - offset

См. также:

asSlice

MemorySegment asSlice(long offset, long newSize, long byteAlignment)

Возвращает срез этого сегмента памяти по заданному смещению с предоставленным ограничением выравнивания. Адрес возвращаемого сегмента — адрес этого сегмента плюс заданное смещение; его размер задаётся аргументом.

Если этот сегмент только для чтения, возвращаемый сегмент также только для чтения.

Параметры:: offset - новое смещение начала сегмента (относительно адреса этого сегмента), заданное в байтах; newSize - новый размер сегмента, заданный в байтах; byteAlignment - ограничение выравнивания (в байтах) возвращаемого среза
Возвращает:: срез этого сегмента памяти
Исключения:: IndexOutOfBoundsException - если offset < 0, offset > byteSize(), newSize < 0 или newSize > byteSize() - offset; IllegalArgumentException - если к этому сегменту невозможно получить доступ по offset с предоставленным ограничением выравнивания; IllegalArgumentException - если byteAlignment <= 0, или byteAlignment не является степенью двойки

asSlice

MemorySegment asSlice(long offset, MemoryLayout layout)

Возвращает срез этого сегмента памяти с заданной структурой по заданному смещению. Адрес возвращаемого сегмента — адрес этого сегмента плюс заданное смещение; его размер совпадает с размером предоставленной структуры.

Эквивалентно следующему коду:

asSlice(offset, layout.byteSize(), layout.byteAlignment());

Если этот сегмент только для чтения, возвращаемый сегмент также только для чтения.

Параметры:

offset - новое смещение начала сегмента (относительно адреса этого сегмента), заданное в байтах

layout - структура сегмента среза

Возвращает:

срез этого сегмента памяти

Исключения:

IndexOutOfBoundsException - если offset < 0, offset > byteSize() или layout.byteSize() > byteSize() - offset

IllegalArgumentException - если к этому сегменту невозможно получить доступ по offset с ограничением выравнивания, указанным в layout

См. также:

asSlice

MemorySegment asSlice(long offset)

Возвращает фрагмент этого сегмента памяти по заданному смещению. Адрес возвращаемого сегмента — это адрес этого сегмента плюс заданное смещение; его размер вычисляется путём вычитания указанного смещения из размера этого сегмента.

Эквивалентно следующему коду:

asSlice(offset, byteSize() - offset);

Если этот сегмент является только для чтения, то возвращаемый сегмент также является только для чтения.

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

Параметры:

offset - Новое смещение начала сегмента (относительно адреса этого сегмента), указанное в байтах

Возвращает:

фрагмент этого сегмента памяти

Исключения:

IndexOutOfBoundsException - если offset < 0 или offset > byteSize()

См. также:

reinterpret

MemorySegment reinterpret(long newSize)

reinterpret — это ограниченный метод платформы Java.

Программы могут использовать reinterpret только при включенном доступе к ограниченным методам.

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

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

Если этот сегмент является только для чтения, то возвращаемый сегмент также является только для чтения.

Параметры:: newSize - размер возвращаемого сегмента
Возвращает:: новый сегмент памяти с тем же адресом и областью видимости, что и этот сегмент, но с новым указанным размером
Исключения:: IllegalArgumentException - если newSize < 0; UnsupportedOperationException - если этот сегмент не является родным сегментом; IllegalCallerException - если вызывающий модуль не имеет разрешения на доступ к нативным ресурсам

reinterpret

MemorySegment reinterpret(Arena arena, Consumer<MemorySegment> cleanup)

reinterpret — это ограниченный метод платформы Java.

Программы могут использовать reinterpret только при включенном доступе к ограниченным методам.

Возвращает новый сегмент памяти с тем же адресом и размером, что и этот сегмент, но с указанной областью видимости. Таким образом, к возвращаемому сегменту нельзя обратиться после закрытия предоставленной области. Кроме того, к возвращаемому сегменту можно получить доступ в соответствии с ограничениями, связанными с предоставленной областью: то есть, если предоставленная область является ограниченной областью, к возвращаемому сегменту может получить доступ только владелец потока этой области, независимо от ограничений доступа к данному сегменту. Другими словами, этот метод возвращает сегмент, который можно использовать как любой другой сегмент, выделенный с использованием предоставленной области. Однако, возвращаемый сегмент использует ту же область памяти, что и исходный сегмент. Таким образом, область памяти, поддерживающая возвращаемый сегмент, освобождается только при закрытии области исходного сегмента. Это может привести к проблемам «использование после освобождения», поскольку к возвращаемому сегменту можно обратиться *после* того, как его область памяти была освобождена с помощью области исходного сегмента.

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

MemorySegment cleanupSegment = MemorySegment.ofAddress(this.address())
                                            .reinterpret(byteSize());

То есть, действие очистки получает сегмент, связанный со глобальной областью, и доступный из любого потока. Размер сегмента, принятого действием очистки, равен byteSize().

Если этот сегмент является только для чтения, то возвращаемый сегмент также является только для чтения.

Примечание API:: Действие очистки (если оно присутствует) должно позаботиться о том, чтобы не передавать полученный сегмент внешним клиентам, которые могут обратиться к сегменту после того, как его область памяти больше недоступна. Кроме того, если предоставленный контекст является контекстом автоматической области, действие очистки не должно препятствовать тому, чтобы контекст стал недоступным. Невыполнение этого условия приведет к тому, что области памяти, выделенные автоматической областью, не будут освобождены.
Параметры:: arena - область, которая будет ассоциирована с возвращаемым сегментом; cleanup - действие очистки, которое должно быть выполнено при закрытии предоставленной области (может быть null)
Возвращает:: новый сегмент памяти с неограниченным размером
Исключения:: IllegalStateException - если arena.scope().isAlive() == false; UnsupportedOperationException - если этот сегмент не является родным сегментом; IllegalCallerException - если вызывающий модуль не имеет разрешения на доступ к нативным ресурсам

reinterpret

MemorySegment reinterpret(long newSize, Arena arena, Consumer<MemorySegment> cleanup)

reinterpret — это ограниченный метод платформы Java.

Программы могут использовать reinterpret только при включенном доступе к ограниченным методам.

Возвращает новый сегмент с тем же адресом, что и этот сегмент, но с указанным размером и областью видимости. Таким образом, к возвращаемому сегменту нельзя получить доступ после закрытия предоставленной области. Кроме того, если возвращаемый сегмент может быть доступен в соответствии с ограничениями, связанными с предоставленной областью: то есть, если предоставленная область является ограниченной областью, к возвращаемому сегменту может получить доступ только владелец потока этой области, независимо от ограничений доступа к данному сегменту. Другими словами, этот метод возвращает сегмент, который можно использовать как любой другой сегмент, выделенный с использованием предоставленной области. Однако, возвращаемый сегмент использует ту же область памяти, что и исходный сегмент. Таким образом, область памяти, поддерживающая возвращаемый сегмент, освобождается только при закрытии области исходного сегмента. Это может привести к проблемам «использование после освобождения», поскольку к возвращаемому сегменту можно обратиться *после* того, как его область памяти была освобождена с помощью области исходного сегмента.

MemorySegment cleanupSegment = MemorySegment.ofAddress(this.address())
                                            .reinterpret(newSize);

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

Если этот сегмент является только для чтения, то возвращаемый сегмент также является только для чтения.

Примечание API:: Действие очистки (если оно присутствует) должно позаботиться о том, чтобы не передавать полученный сегмент внешним клиентам, которые могут обратиться к сегменту после того, как его область памяти больше недоступна. Кроме того, если предоставленный контекст является контекстом автоматической области, действие очистки не должно препятствовать тому, чтобы контекст стал недоступным. Невыполнение этого условия приведет к тому, что области памяти, выделенные автоматической областью, не будут освобождены.
Параметры:: newSize - размер возвращаемого сегмента; arena - область, которая будет ассоциирована с возвращаемым сегментом; cleanup - действие очистки, которое должно быть выполнено при закрытии предоставленной области (может быть null).
Возвращает:: новый сегмент, у которого адрес такой же, как у этого сегмента, но с новым размером и областью видимости, установленной в соответствии с предоставленной областью.
Исключения:: UnsupportedOperationException - если этот сегмент не является родным сегментом; newSize < 0 - если newSize < 0; arena.scope().isAlive() == false - если arena.scope().isAlive() == false; IllegalCallerException - если вызывающий модуль не имеет разрешения на доступ к нативным ресурсам

isReadOnly

boolean isReadOnly()

Возвращает true, если этот сегмент является только для чтения.

Возвращает:

true, если этот сегмент является только для чтения

См. также:

END_OF_DOCUMENT_MARKER

asReadOnly

MemorySegment asReadOnly()

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

Возвращает:

представление для чтения без записи этого сегмента

См. также:

isNative

boolean isNative()

Возвращает true, если этот сегмент является нативным сегментом.

Нативный сегмент создается, например, с помощью Arena.allocate(long, long) (и родственных) фабрик, или путем обертывания прямого буфера.

Возвращает:: true, если этот сегмент является нативным сегментом

isMapped

boolean isMapped()

Возвращает true, если этот сегмент является отображенным сегментом. Отображенный сегмент памяти создается, например, с помощью FileChannel.map(FileChannel.MapMode, long, long, Arena) фабрики или путем обертывания отображенного буфера байтов.

Возвращает:: true, если этот сегмент является отображенным сегментом

asOverlappingSlice

Optional<MemorySegment> asOverlappingSlice(MemorySegment other)

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

Два сегмента S1 и S2 считаются перекрывающимися, если можно найти по крайней мере два среза L1 (из S1) и L2 (из S2), которые опираются на одну и ту же область памяти. Таким образом, невозможно, чтобы нативный сегмент перекрывался с сегментом кучи; в этом случае или когда перекрытия нет, возвращается пустой Optional.

Параметры:: other - сегмент, с которым проверяется перекрытие с этим сегментом
Возвращает:: срез этого сегмента (где происходит перекрытие)

fill

MemorySegment fill(byte value)

Заполняет содержимое этого сегмента памяти заданным значением.

Более конкретно, заданное значение записывается в каждый адрес этого сегмента. Эквивалентно (но, вероятно, более эффективно, чем) следующему коду:

for (long offset = 0; offset < segment.byteSize(); offset++) {
    segment.set(ValueLayout.JAVA_BYTE, offset, value);
}

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

Этот метод может быть полезен для инициализации или сброса содержимого сегмента памяти.

Параметры:: value - значение, которое нужно записать в этот сегмент
Возвращает:: этот сегмент памяти
Исключения:: IllegalStateException - если область действия, связанная с этим сегментом, не является активной; WrongThreadException - если этот метод вызывается из потока T, при котором isAccessibleBy(T) == false; IllegalArgumentException - если этот сегмент является только для чтения

copyFrom

MemorySegment copyFrom(MemorySegment src)

Выполняет копирование из заданного сегмента-источника в этот сегмент. Более конкретно, байты с офсетом 0 по src.byteSize() - 1 в сегменте-источнике копируются в этот сегмент с офсетом 0 по src.byteSize() - 1.

Вызов этого метода эквивалентен следующему коду:

MemorySegment.copy(src, 0, this, 0, src.byteSize());

Параметры:: src - сегмент-источник
Возвращает:: этот сегмент
Исключения:: IndexOutOfBoundsException - если src.byteSize() > this.byteSize(); IllegalStateException - если область действия, связанная с этим сегментом, не является активной; WrongThreadException - если этот метод вызывается из потока T, при котором isAccessibleBy(T) == false; IllegalStateException - если область действия, связанная с src, не является активной; WrongThreadException - если этот метод вызывается из потока T, при котором src.isAccessibleBy(T) == false; IllegalArgumentException - если этот сегмент является только для чтения

mismatch

long mismatch(MemorySegment other)

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

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

Параметры:: other - сегмент, который проверяется на несовпадение с этим сегментом
Возвращает:: относительное смещение (в байтах) первого несовпадения между этим и заданным другим сегментом, иначе -1, если несовпадения нет
Исключения:: IllegalStateException - если область действия, связанная с этим сегментом, не является активной; WrongThreadException - если этот метод вызывается из потока T, при котором isAccessibleBy(T) == false; IllegalStateException - если область действия, связанная с other, не является активной; WrongThreadException - если этот метод вызывается из потока T, при котором other.isAccessibleBy(T) == false

isLoaded

boolean isLoaded()

Определяет, все ли содержимое этого отображенного сегмента находится в физической памяти.

Значение true подразумевает, что, скорее всего, все данные в этом сегменте находятся в физической памяти и, следовательно, могут быть обработаны без возникновения виртуальных страниц памяти или операций ввода-вывода. Значение false не обязательно означает, что содержимое этого сегмента не находится в физической памяти.

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

Возвращает:: true, если вероятно, что содержимое этого сегмента находится в физической памяти
Исключения:: IllegalStateException - если область действия, связанная с этим сегментом, не является активной; WrongThreadException - если этот метод вызывается из потока T, при котором isAccessibleBy(T) == false; UnsupportedOperationException - если этот сегмент не является отображенным сегментом памяти, например, если isMapped() == false

load

void load()

Загружает содержимое этого отображенного сегмента в физическую память.

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

Исключения:: IllegalStateException - если область действия, связанная с этим сегментом, не является активной; WrongThreadException - если этот метод вызывается из потока T, при котором isAccessibleBy(T) == false; UnsupportedOperationException - если этот сегмент не является отображенным сегментом памяти, например, если isMapped() == false

unload

void unload()

Выгружает содержимое этого отображенного сегмента из физической памяти.

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

Исключения:: IllegalStateException - если область действия, связанная с этим сегментом, не является активной; WrongThreadException - если этот метод вызывается из потока T, при котором isAccessibleBy(T) == false; UnsupportedOperationException - если этот сегмент не является отображенным сегментом памяти, например, если isMapped() == false

END_OF_DOCUMENT_MARKER

force

void force()

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

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

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

Если этот сегмент не был сопоставлен в режиме чтения/записи (FileChannel.MapMode.READ_WRITE), то вызов этого метода может не иметь никакого эффекта. В частности, метод не оказывает никакого влияния для сегментов, сопоставленных в режимах только для чтения или частного отображения. Этот метод может или не может иметь эффект для режимов сопоставления, специфичных для реализации.

Throws:: IllegalStateException - если область видимости (scope), связанная с этим сегментом, не является активной; WrongThreadException - если этот метод вызывается из потока T, при котором isAccessibleBy(T) == false; UnsupportedOperationException - если этот сегмент не является сопоставленным сегментом памяти, например, если isMapped() == false; UncheckedIOException - если при записи содержимого этого сегмента на связанное устройство хранения произошла ошибка ввода-вывода

asByteBuffer

ByteBuffer asByteBuffer()

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

Он является только для чтения, если этот сегмент является сегментом только для чтения;
Его позиция установлена в ноль;
Его емкость и предел оба установлены в размер этого сегмента. По этой причине буфер байтов не может быть возвращён, если размер этого сегмента больше Integer.MAX_VALUE;
Он является прямым буфером, если это сегмент нативного типа.

Жизненный цикл возвращаемого буфера связан с жизненным циклом этого сегмента. То есть, доступ к возвращаемому буферу после того, как область видимости, связанная с этим сегментом, больше не активна, вызовет исключение IllegalStateException. Аналогично, доступ к возвращаемому буферу из потока T таким образом, что isAccessible(T) == false, вызовет исключение WrongThreadException.

Если этот сегмент доступен только из одного потока, вызов операций ввода-вывода чтения/записи на полученный буфер может привести к возбуждению неопределенных исключений. Примеры таких проблемных операций - AsynchronousSocketChannel.read(ByteBuffer) и AsynchronousSocketChannel.write(ByteBuffer).

Наконец, порядок байтов полученного буфера - ByteOrder.BIG_ENDIAN; это можно изменить с помощью ByteBuffer.order(java.nio.ByteOrder).

Returns:: a ByteBuffer представление этого сегмента памяти
Throws:: UnsupportedOperationException - если этот сегмент не может быть сопоставлен с экземпляром ByteBuffer, например, если это кучный сегмент, поддерживаемый массивом, отличным от byte[], или если его размер больше Integer.MAX_VALUE

toArray

byte[] toArray(ValueLayout.OfByte elementLayout)

Копирует содержимое этого сегмента памяти в новый массив байтов.

Parameters:: elementLayout - макет элемента-источника. Если порядок байтов, связанный с макетом, отличается от родного порядка, будет выполнена операция перестановки байтов для каждого элемента массива
Returns:: новый массив байтов, содержимое которого скопировано из этого сегмента памяти
Throws:: IllegalStateException - если область видимости (scope), связанная с этим сегментом, не является активной; WrongThreadException - если этот метод вызывается из потока T, при котором isAccessibleBy(T) == false; IllegalStateException - если содержимое этого сегмента не может быть скопировано в экземпляр byte[], например, если его размер превышает Integer.MAX_VALUE

toArray

short[] toArray(ValueLayout.OfShort elementLayout)

Копирует содержимое этого сегмента памяти в новый массив целых чисел со знаком короче.

Parameters:: elementLayout - макет элемента-источника. Если порядок байтов, связанный с макетом, отличается от родного порядка, будет выполнена операция перестановки байтов для каждого элемента массива
Returns:: новый массив целых чисел со знаком короче, содержимое которого скопировано из этого сегмента памяти
Throws:: IllegalStateException - если область видимости (scope), связанная с этим сегментом, не является активной; WrongThreadException - если этот метод вызывается из потока T, при котором isAccessibleBy(T) == false; IllegalStateException - если содержимое этого сегмента не может быть скопировано в экземпляр short[], например, из-за byteSize() % 2 != 0 или byteSize() / 2 > Integer.MAX_VALUE

toArray

char[] toArray(ValueLayout.OfChar elementLayout)

Копирует содержимое этого сегмента памяти в новый массив символов.

Parameters:: elementLayout - макет элемента-источника. Если порядок байтов, связанный с макетом, отличается от родного порядка, будет выполнена операция перестановки байтов для каждого элемента массива
Returns:: новый массив символов, содержимое которого скопировано из этого сегмента памяти
Throws:: IllegalStateException - если область видимости (scope), связанная с этим сегментом, не является активной; WrongThreadException - если этот метод вызывается из потока T, при котором isAccessibleBy(T) == false; IllegalStateException - если содержимое этого сегмента не может быть скопировано в экземпляр char[], например, из-за byteSize() % 2 != 0 или byteSize() / 2 > Integer.MAX_VALUE

toArray

int[] toArray(ValueLayout.OfInt elementLayout)

Копирует содержимое этого сегмента памяти в новый массив целых чисел.

Parameters:: elementLayout - макет элемента-источника. Если порядок байтов, связанный с макетом, отличается от родного порядка, будет выполнена операция перестановки байтов для каждого элемента массива.
Returns:: новый массив целых чисел, содержимое которого скопировано из этого сегмента памяти
Throws:: IllegalStateException - если область видимости (scope), связанная с этим сегментом, не является активной; WrongThreadException - если этот метод вызывается из потока T, при котором isAccessibleBy(T) == false; IllegalStateException - если содержимое этого сегмента не может быть скопировано в экземпляр int[], например, из-за byteSize() % 4 != 0 или byteSize() / 4 > Integer.MAX_VALUE

toArray

float[] toArray(ValueLayout.OfFloat elementLayout)

Копирует содержимое этого сегмента памяти в новый массив чисел с плавающей точкой.

Parameters:: elementLayout - макет элемента-источника. Если порядок байтов, связанный с макетом, отличается от родного порядка, будет выполнена операция перестановки байтов для каждого элемента массива
Returns:: новый массив чисел с плавающей точкой, содержимое которого скопировано из этого сегмента памяти
Throws:: IllegalStateException - если область видимости (scope), связанная с этим сегментом, не является активной; WrongThreadException - если этот метод вызывается из потока T, при котором isAccessibleBy(T) == false; IllegalStateException - если содержимое этого сегмента не может быть скопировано в экземпляр float[], например, из-за byteSize() % 4 != 0 или byteSize() / 4 > Integer.MAX_VALUE

toArray

long[] toArray(ValueLayout.OfLong elementLayout)

Копирует содержимое этого сегмента памяти в новый массив целых чисел с длинной.

Parameters:: elementLayout - макет элемента-источника. Если порядок байтов, связанный с макетом, отличается от родного порядка, будет выполнена операция перестановки байтов для каждого элемента массива
Returns:: новый массив целых чисел с длинной, содержимое которого скопировано из этого сегмента памяти
Throws:: IllegalStateException - если область видимости (scope), связанная с этим сегментом, не является активной; WrongThreadException - если этот метод вызывается из потока T, при котором isAccessibleBy(T) == false; IllegalStateException - если содержимое этого сегмента не может быть скопировано в экземпляр long[], например, из-за byteSize() % 8 != 0 или byteSize() / 8 > Integer.MAX_VALUE

toArray

double[] toArray(ValueLayout.OfDouble elementLayout)

Копирует содержимое этого сегмента памяти в новый массив double.

Parameters:: elementLayout - макет исходного элемента. Если порядок байтов, связанный с макетом, отличается от родного порядка, для каждого элемента массива будет выполнена операция перестановки байтов
Returns:: новый массив double, содержимое которого скопировано из этого сегмента памяти
Throws:: IllegalStateException - если область, связанная с этим сегментом, не активна; WrongThreadException - если этот метод вызывается из потока T, при котором isAccessibleBy(T) == false; IllegalStateException - если содержимое этого сегмента не может быть скопировано в экземпляр double[], например, потому что byteSize() % 8 != 0 или byteSize() / 8 > Integer.MAX_VALUE

getString

String getString(long offset)

Читает строку с завершающим нулем из этого сегмента по заданному смещению, используя кодировку UTF-8.

Вызов этого метода эквивалентен следующему коду:

 getString(offset, StandardCharsets.UTF_8);

Parameters:: offset - смещение в байтах (относительно адреса этого сегмента), в котором произойдет эта операция доступа
Returns:: строка Java, созданная из байтов, прочитанных из указанного начального адреса до (но не включая) первого символа завершения строки (если он найден)
Throws:: IllegalArgumentException - если размер строки превышает максимальный размер строки, поддерживаемый платформой; IndexOutOfBoundsException - если offset < 0; IndexOutOfBoundsException - если символ завершения строки (например, '\0') отсутствует в этом сегменте между заданным offset и концом этого сегмента.; IllegalStateException - если область, связанная с этим сегментом, не активна; WrongThreadException - если этот метод вызывается из потока T, при котором isAccessibleBy(T) == false

getString

String getString(long offset, Charset charset)

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

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

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

    byte[] bytes = new byte[length];
    MemorySegment.copy(segment, JAVA_BYTE, offset, bytes, 0, length);
    return new String(bytes, charset);

Parameters:: offset - смещение в байтах (относительно адреса этого сегмента), в котором произойдет эта операция доступа; charset - кодировка, используемая для декодирования байтов строки. charset должна быть стандартной кодировкой
Returns:: строка Java, созданная из байтов, прочитанных из указанного начального адреса до (но не включая) первого символа завершения строки (если он найден)
Throws:: IllegalArgumentException - если размер строки превышает максимальный размер строки, поддерживаемый платформой; IndexOutOfBoundsException - если offset < 0; IndexOutOfBoundsException - если символ завершения строки (например, '\0') отсутствует в этом сегменте между заданным offset и концом этого сегмента. Размер в байтах символа завершения строки зависит от выбранной charset. Например, это 1 для StandardCharsets.US_ASCII и 2 для StandardCharsets.UTF_16; IllegalStateException - если область, связанная с этим сегментом, не активна; WrongThreadException - если этот метод вызывается из потока T, при котором isAccessibleBy(T) == false; IllegalArgumentException - если charset не является стандартной кодировкой

setString

void setString(long offset, String str)

Записывает заданную строку в этот сегмент по заданному смещению, преобразуя её в последовательность байтов с завершающим нулем, используя кодировку UTF-8.

Вызов этого метода эквивалентен следующему коду:

 setString(offset, str, StandardCharsets.UTF_8);

Parameters:: offset - смещение в байтах (относительно адреса этого сегмента), в котором произойдет операция записи; окончательный адрес этой операции записи можно выразить как address() + offset.; str - строка Java, которая будет записана в этот сегмент
Throws:: IndexOutOfBoundsException - если offset < 0; IndexOutOfBoundsException - если offset > byteSize() - (B + 1), где B — размер в байтах строки, закодированной с помощью кодировки UTF-8 str.getBytes(StandardCharsets.UTF_8).length); IllegalStateException - если область, связанная с этим сегментом, не активна; WrongThreadException - если этот метод вызывается из потока T, при котором isAccessibleBy(T) == false; IllegalArgumentException - если этот сегмент является только для чтения

setString

void setString(long offset, String str, Charset charset)

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

Если заданная строка содержит любые '\0' символы, они также будут скопированы. Это означает, что в зависимости от метода, используемого для чтения строки, например, getString(long), строка будет казаться усечённой при повторном чтении.

Parameters:

offset - смещение в байтах (относительно адреса этого сегмента), в котором произойдет операция записи; окончательный адрес этой операции записи можно выразить как address() + offset

str - строка Java, которая будет записана в этот сегмент

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

Throws:

IndexOutOfBoundsException - если offset < 0

IndexOutOfBoundsException - если offset > byteSize() - (B + N), где:

B — размер в байтах строки, закодированной с помощью указанной кодировки (например, str.getBytes(charset).length);
N — размер (в байтах) символа завершения строки в соответствии с указанной кодировкой. Например, это 1 для StandardCharsets.US_ASCII и 2 для StandardCharsets.UTF_16.

IllegalStateException - если область, связанная с этим сегментом, не активна

WrongThreadException - если этот метод вызывается из потока T, при котором isAccessibleBy(T) == false

IllegalArgumentException - если charset не является стандартной кодировкой

IllegalArgumentException - если этот сегмент является только для чтения

ofBuffer

static MemorySegment ofBuffer(Buffer buffer)

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

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

Если предоставленный буфер получен, вызвав asByteBuffer() на сегменте памяти, область которого S, возвращаемый сегмент будет связан с той же областью S. В противном случае область возвращаемого сегмента — это автоматическая область, которая сохраняет доступность предоставленного буфера. Таким образом, если предоставленный буфер является прямым буфером, область его поддержки не будет освобождена до тех пор, пока возвращаемый сегмент или любой из его фрагментов не потеряют доступность.

Parameters:: buffer - экземпляр буфера, который необходимо преобразовать в новый сегмент памяти
Returns:: сегмент памяти, полученный из указанного экземпляра буфера
Throws:: IllegalArgumentException - если предоставленный buffer — это буфер кучи, но не поддерживается массивом; Например, буферы, полученные напрямую или косвенно через (CharBuffer.wrap(CharSequence) или CharBuffer.wrap(char[], int, int), не поддерживаются массивом.

ofArray

static MemorySegment ofArray(byte[] byteArray)

Создаёт сегмент кучи, поддерживаемый областью памяти в куче, которая содержит указанный массив байтов. Область действия возвращаемого сегмента — автоматический scope, который сохраняет доступность данного массива. Возвращаемый сегмент всегда доступен из любого потока. Его address() устанавливается в ноль.

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

ofArray

static MemorySegment ofArray(char[] charArray)

Создаёт сегмент кучи, поддерживаемый областью памяти в куче, которая содержит указанный массив символов. Область действия возвращаемого сегмента — автоматический scope, который сохраняет доступность данного массива. Возвращаемый сегмент всегда доступен из любого потока. Его address() устанавливается в ноль.

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

ofArray

static MemorySegment ofArray(short[] shortArray)

Создаёт сегмент кучи, поддерживаемый областью памяти в куче, которая содержит указанный массив целых чисел с коротким значением. Область действия возвращаемого сегмента — автоматический scope, который сохраняет доступность данного массива. Возвращаемый сегмент всегда доступен из любого потока. Его address() устанавливается в ноль.

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

ofArray

static MemorySegment ofArray(int[] intArray)

Создаёт сегмент кучи, поддерживаемый областью памяти в куче, которая содержит указанный массив целых чисел. Область действия возвращаемого сегмента — автоматический scope, который сохраняет доступность данного массива. Возвращаемый сегмент всегда доступен из любого потока. Его address() устанавливается в ноль.

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

ofArray

static MemorySegment ofArray(float[] floatArray)

Создаёт сегмент кучи, поддерживаемый областью памяти в куче, которая содержит указанный массив чисел с плавающей точкой. Область действия возвращаемого сегмента — автоматический scope, который сохраняет доступность данного массива. Возвращаемый сегмент всегда доступен из любого потока. Его address() устанавливается в ноль.

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

ofArray

static MemorySegment ofArray(long[] longArray)

Создаёт сегмент кучи, поддерживаемый областью памяти в куче, которая содержит указанный массив длинных целых чисел. Область действия возвращаемого сегмента — автоматический scope, который сохраняет доступность данного массива. Возвращаемый сегмент всегда доступен из любого потока. Его address() устанавливается в ноль.

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

ofArray

static MemorySegment ofArray(double[] doubleArray)

Создаёт сегмент кучи, поддерживаемый областью памяти в куче, которая содержит указанный массив чисел с двойной точностью. Область действия возвращаемого сегмента — автоматический scope, который сохраняет доступность данного массива. Возвращаемый сегмент всегда доступен из любого потока. Его address() устанавливается в ноль.

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

ofAddress

static MemorySegment ofAddress(long address)

Создаёт сегмент с нулевой длиной, нативный сегмент из заданного значения адреса.

Возвращаемый сегмент связан со глобальным scope и доступен из любого потока.

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

Параметры:: address - адрес возвращаемого нативного сегмента
Возвращает:: нативный сегмент нулевой длины с заданным адресом

copy

static void copy(MemorySegment srcSegment, long srcOffset, MemorySegment dstSegment, long dstOffset, long bytes)

Выполняет массовую копию из исходного сегмента в целевой сегмент. Более конкретно, байты с смещением srcOffset по srcOffset + bytes - 1 в исходном сегменте копируются в целевой сегмент по смещению dstOffset по dstOffset + bytes - 1.

Если исходный сегмент перекрывается с целевым сегментом, то копирование выполняется так, как если бы байты со смещением srcOffset по srcOffset + bytes - 1 в исходном сегменте были сначала скопированы в временный сегмент размером bytes, а затем содержимое временного сегмента было скопировано в целевой сегмент по смещению dstOffset по dstOffset + bytes - 1.

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

Вызов этого метода эквивалентен следующему коду:

MemorySegment.copy(srcSegment, ValueLayout.JAVA_BYTE, srcOffset, dstSegment, ValueLayout.JAVA_BYTE, dstOffset, bytes);

Параметры:: srcSegment - исходный сегмент; srcOffset - начальное смещение, в байтах, исходного сегмента; dstSegment - целевой сегмент; dstOffset - начальное смещение, в байтах, целевого сегмента; bytes - количество байтов для копирования
Исключения:: IllegalStateException - если область действия, связанная с srcSegment, не активна; WrongThreadException - если этот метод вызывается из потока T, при котором srcSegment.isAccessibleBy(T) == false; IllegalStateException - если область действия, связанная с dstSegment, не активна; WrongThreadException - если этот метод вызывается из потока T, при котором dstSegment.isAccessibleBy(T) == false; IndexOutOfBoundsException - если srcOffset > srcSegment.byteSize() - bytes; IndexOutOfBoundsException - если dstOffset > dstSegment.byteSize() - bytes; IndexOutOfBoundsException - если либо srcOffset, dstOffset или bytes являются < 0; IllegalArgumentException - если dstSegment является только для чтения

копировать

static void copy(MemorySegment srcSegment, ValueLayout srcElementLayout, long srcOffset, MemorySegment dstSegment, ValueLayout dstElementLayout, long dstOffset, long elementCount)

Выполняет операцию копирования данных из исходного сегмента в целевой сегмент. Более конкретно, если S — размер элемента в байтах, байты с смещением srcOffset до srcOffset + (elementCount * S) - 1 в исходном сегменте копируются в целевой сегмент по смещению dstOffset до dstOffset + (elementCount * S) - 1.

Копирование происходит поэлементно: байты в исходном сегменте интерпретируются как последовательность элементов с макетом srcElementLayout, а байты в целевом сегменте — как последовательность элементов с макетом dstElementLayout. Оба макета элементов должны иметь одинаковый размер S. Если порядок байтов в двух предоставленных макетах элементов отличается, соответствующие байты каждого копируемого элемента меняются местами во время операции копирования.

Если исходный сегмент перекрывается с целевым сегментом, то копирование выполняется так, как будто байты со смещением srcOffset до srcOffset + (elementCount * S) - 1 в исходном сегменте сначала копируются в временный сегмент размером bytes, а затем содержимое временного сегмента копируется в целевой сегмент по смещению dstOffset до dstOffset + (elementCount * S) - 1.

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

Параметры:: srcSegment - исходный сегмент; srcElementLayout - макет элемента, связанный с исходным сегментом; srcOffset - начальное смещение в байтах исходного сегмента; dstSegment - целевой сегмент; dstElementLayout - макет элемента, связанный с целевым сегментом; dstOffset - начальное смещение в байтах целевого сегмента; elementCount - количество копируемых элементов
Исключения:: IllegalArgumentException - если макеты элементов имеют разные размеры, если исходный (соответственно, целевой) сегмент/смещение несовместимы с ограничением выравнивания в исходном (соответственно, целевом) макете элемента; IllegalArgumentException - если srcElementLayout.byteAlignment() > srcElementLayout.byteSize(); IllegalArgumentException - если dstElementLayout.byteAlignment() > dstElementLayout.byteSize(); IllegalStateException - если область, связанная с srcSegment, не активна; WrongThreadException - если этот метод вызван из потока T, при котором srcSegment.isAccessibleBy(T) == false; IllegalStateException - если область, связанная с dstSegment, не активна; WrongThreadException - если этот метод вызван из потока T, при котором dstSegment.isAccessibleBy(T) == false; IllegalArgumentException - если dstSegment является только для чтения; IndexOutOfBoundsException - если elementCount * srcLayout.byteSize() переполняется; IndexOutOfBoundsException - если elementCount * dtsLayout.byteSize() переполняется; IndexOutOfBoundsException - если srcOffset > srcSegment.byteSize() - (elementCount * srcLayout.byteSize()); IndexOutOfBoundsException - если dstOffset > dstSegment.byteSize() - (elementCount * dstLayout.byteSize()); IndexOutOfBoundsException - если любой из srcOffset, dstOffset или elementCount является < 0

получить

byte get(ValueLayout.OfByte layout, long offset)

Считывает байт из этого сегмента по указанному смещению с заданным макетом.

Параметры:: layout - макет области памяти для чтения; offset - смещение в байтах (относительно адреса этого сегмента), в котором произойдёт эта операция доступа.
Возвращает:: значение байта, считанного из этого сегмента
Исключения:: IllegalStateException - если область, связанная с этим сегментом, не активна; WrongThreadException - если этот метод вызван из потока T, при котором isAccessibleBy(T) == false; IllegalArgumentException - если операция доступа несовместима с ограничением выравнивания в предоставленном макете; IndexOutOfBoundsException - если offset > byteSize() - layout.byteSize() или offset < 0

установить

void set(ValueLayout.OfByte layout, long offset, byte value)

Записывает байт в этот сегмент по заданному смещению с заданным макетом.

Параметры:: layout - макет области памяти для записи; offset - смещение в байтах (относительно адреса этого сегмента), в котором произойдёт эта операция доступа.; value - значение байта для записи.
Исключения:: IllegalStateException - если область, связанная с этим сегментом, не активна; WrongThreadException - если этот метод вызван из потока T, при котором isAccessibleBy(T) == false; IllegalArgumentException - если операция доступа несовместима с ограничением выравнивания в предоставленном макете; IndexOutOfBoundsException - если offset > byteSize() - layout.byteSize() или offset < 0; IllegalArgumentException - если этот сегмент является только для чтения

получить

boolean get(ValueLayout.OfBoolean layout, long offset)

Считывает булево значение из этого сегмента по указанному смещению с заданным макетом.

Параметры:: layout - макет области памяти для чтения; offset - смещение в байтах (относительно адреса этого сегмента), в котором произойдёт эта операция доступа
Возвращает:: булево значение, считанное из этого сегмента
Исключения:: IllegalStateException - если область, связанная с этим сегментом, не активна; WrongThreadException - если этот метод вызван из потока T, при котором isAccessibleBy(T) == false; IllegalArgumentException - если операция доступа несовместима с ограничением выравнивания в предоставленном макете; IndexOutOfBoundsException - если offset > byteSize() - layout.byteSize() или offset < 0

установить

void set(ValueLayout.OfBoolean layout, long offset, boolean value)

Записывает булево значение в этот сегмент по заданному смещению с заданным макетом.

Параметры:: layout - макет области памяти для записи; offset - смещение в байтах (относительно адреса этого сегмента), в котором произойдёт эта операция доступа; value - булево значение для записи
Исключения:: IllegalStateException - если область, связанная с этим сегментом, не активна; WrongThreadException - если этот метод вызван из потока T, при котором isAccessibleBy(T) == false; IllegalArgumentException - если операция доступа несовместима с ограничением выравнивания в предоставленном макете; IndexOutOfBoundsException - если offset > byteSize() - layout.byteSize() или offset < 0; IllegalArgumentException - если этот сегмент является только для чтения

получить

char get(ValueLayout.OfChar layout, long offset)

Считывает символ char из этого сегмента по указанному смещению с заданным макетом.

Параметры:: layout - макет области памяти для чтения; offset - смещение в байтах (относительно адреса этого сегмента), в котором произойдёт эта операция доступа
Возвращает:: значение char, считанное из этого сегмента
Исключения:: IllegalStateException - если область, связанная с этим сегментом, не активна; WrongThreadException - если этот метод вызван из потока T, при котором isAccessibleBy(T) == false; IllegalArgumentException - если операция доступа несовместима с ограничением выравнивания в предоставленном макете; IndexOutOfBoundsException - если offset > byteSize() - layout.byteSize() или offset < 0

установить

void set(ValueLayout.OfChar layout, long offset, char value)

Записывает символ char в этот сегмент по заданному смещению с заданным макетом.

Параметры:: layout - макет области памяти для записи; offset - смещение в байтах (относительно адреса этого сегмента), в котором произойдёт эта операция доступа.; value - значение char для записи
Исключения:: IllegalStateException - если область, связанная с этим сегментом, не активна; WrongThreadException - если этот метод вызван из потока T, при котором isAccessibleBy(T) == false; IllegalArgumentException - если операция доступа несовместима с ограничением выравнивания в предоставленном макете; IndexOutOfBoundsException - если offset > byteSize() - layout.byteSize() или offset < 0; IllegalArgumentException - если этот сегмент является только для чтения

получить

short get(ValueLayout.OfShort layout, long offset)

Считывает короткое целое число из этого сегмента по заданному смещению с заданной компоновкой.

Параметры:: layout - компоновка области памяти для считывания; offset - смещение в байтах (относительно адреса этого сегмента) для данного доступа
Возвращает:: значение короткого целого числа, считанное из этого сегмента
Исключения:: IllegalStateException - если область действия, связанная с этим сегментом, не активна; WrongThreadException - если этот метод вызван из потока T, при этом isAccessibleBy(T) == false; IllegalArgumentException - если операция доступа несовместима с ограничением выравнивания в предоставленной компоновке; IndexOutOfBoundsException - если offset > byteSize() - layout.byteSize() или offset < 0

установить

void set(ValueLayout.OfShort layout, long offset, short value)

Записывает короткое целое число в этот сегмент по заданному смещению с заданной компоновкой.

Параметры:: layout - компоновка области памяти для записи; offset - смещение в байтах (относительно адреса этого сегмента) для данного доступа.; value - значение короткого целого числа для записи
Исключения:: IllegalStateException - если область действия, связанная с этим сегментом, не активна; WrongThreadException - если этот метод вызван из потока T, при этом isAccessibleBy(T) == false; IllegalArgumentException - если операция доступа несовместима с ограничением выравнивания в предоставленной компоновке; IndexOutOfBoundsException - если offset > byteSize() - layout.byteSize() или offset < 0; IllegalArgumentException - если этот сегмент только для чтения

получить

int get(ValueLayout.OfInt layout, long offset)

Считывает целое число из этого сегмента по заданному смещению с заданной компоновкой.

Параметры:: layout - компоновка области памяти для считывания; offset - смещение в байтах (относительно адреса этого сегмента) для данного доступа.
Возвращает:: значение целого числа, считанное из этого сегмента
Исключения:: IllegalStateException - если область действия, связанная с этим сегментом, не активна; WrongThreadException - если этот метод вызван из потока T, при этом isAccessibleBy(T) == false; IllegalArgumentException - если операция доступа несовместима с ограничением выравнивания в предоставленной компоновке; IndexOutOfBoundsException - если offset > byteSize() - layout.byteSize() или offset < 0

установить

void set(ValueLayout.OfInt layout, long offset, int value)

Записывает целое число в этот сегмент по заданному смещению с заданной компоновкой.

Параметры:: layout - компоновка области памяти для записи; offset - смещение в байтах (относительно адреса этого сегмента) для данного доступа; value - значение целого числа для записи
Исключения:: IllegalStateException - если область действия, связанная с этим сегментом, не активна; WrongThreadException - если этот метод вызван из потока T, при этом isAccessibleBy(T) == false; IllegalArgumentException - если операция доступа несовместима с ограничением выравнивания в предоставленной компоновке; IndexOutOfBoundsException - если offset > byteSize() - layout.byteSize() или offset < 0; IllegalArgumentException - если этот сегмент только для чтения

получить

float get(ValueLayout.OfFloat layout, long offset)

Считывает число с плавающей точкой из этого сегмента по заданному смещению с заданной компоновкой.

Параметры:: layout - компоновка области памяти для считывания; offset - смещение в байтах (относительно адреса этого сегмента) для данного доступа
Возвращает:: значение числа с плавающей точкой, считанное из этого сегмента
Исключения:: IllegalStateException - если область действия, связанная с этим сегментом, не активна; WrongThreadException - если этот метод вызван из потока T, при этом isAccessibleBy(T) == false; IllegalArgumentException - если операция доступа несовместима с ограничением выравнивания в предоставленной компоновке; IndexOutOfBoundsException - если offset > byteSize() - layout.byteSize() или offset < 0

установить

void set(ValueLayout.OfFloat layout, long offset, float value)

Записывает число с плавающей точкой в этот сегмент по заданному смещению с заданной компоновкой.

Параметры:: layout - компоновка области памяти для записи; offset - смещение в байтах (относительно адреса этого сегмента) для данного доступа; value - значение числа с плавающей точкой для записи
Исключения:: IllegalStateException - если область действия, связанная с этим сегментом, не активна; WrongThreadException - если этот метод вызван из потока T, при этом isAccessibleBy(T) == false; IllegalArgumentException - если операция доступа несовместима с ограничением выравнивания в предоставленной компоновке; IndexOutOfBoundsException - если offset > byteSize() - layout.byteSize() или offset < 0; IllegalArgumentException - если этот сегмент только для чтения

получить

long get(ValueLayout.OfLong layout, long offset)

Считывает длинное целое число из этого сегмента по заданному смещению с заданной компоновкой.

Параметры:: layout - компоновка области памяти для считывания; offset - смещение в байтах (относительно адреса этого сегмента) для данного доступа.
Возвращает:: значение длинного целого числа, считанное из этого сегмента
Исключения:: IllegalStateException - если область действия, связанная с этим сегментом, не активна; WrongThreadException - если этот метод вызван из потока T, при этом isAccessibleBy(T) == false; IllegalArgumentException - если операция доступа несовместима с ограничением выравнивания в предоставленной компоновке; IndexOutOfBoundsException - если offset > byteSize() - layout.byteSize() или offset < 0

установить

void set(ValueLayout.OfLong layout, long offset, long value)

Записывает длинное целое число в этот сегмент по заданному смещению с заданной компоновкой.

Параметры:: layout - компоновка области памяти для записи; offset - смещение в байтах (относительно адреса этого сегмента) для данного доступа.; value - значение длинного целого числа для записи.
Исключения:: IllegalStateException - если область действия, связанная с этим сегментом, не активна; WrongThreadException - если этот метод вызван из потока T, при этом isAccessibleBy(T) == false; IllegalArgumentException - если операция доступа несовместима с ограничением выравнивания в предоставленной компоновке; IndexOutOfBoundsException - если offset > byteSize() - layout.byteSize() или offset < 0; IllegalArgumentException - если этот сегмент только для чтения

получить

double get(ValueLayout.OfDouble layout, long offset)

Считывает число двойной точности из этого сегмента по заданному смещению с заданной компоновкой.

Параметры:: layout - компоновка области памяти для считывания; offset - смещение в байтах (относительно адреса этого сегмента) для данного доступа
Возвращает:: значение числа двойной точности, считанное из этого сегмента
Исключения:: IllegalStateException - если область действия, связанная с этим сегментом, не активна; WrongThreadException - если этот метод вызван из потока T, при этом isAccessibleBy(T) == false; IllegalArgumentException - если операция доступа несовместима с ограничением выравнивания в предоставленной компоновке; IndexOutOfBoundsException - если offset > byteSize() - layout.byteSize() или offset < 0

END_OF_DOCUMENT_MARKER

set

void set(ValueLayout.OfDouble layout, long offset, double value)

Записывает значение double в этот сегмент по заданному смещению, используя заданный layout.

Параметры:: layout - layout области памяти, которая будет записана; offset - смещение в байтах (относительно адреса этого сегмента), по которому будет выполняться операция доступа; value - значение double, которое будет записано
Исключения:: IllegalStateException - если область видимости (scope), связанная с этим сегментом, не активна; WrongThreadException - если этот метод вызывается из потока T, так что isAccessibleBy(T) == false; IllegalArgumentException - если операция доступа несовместима с ограничением выравнивания в предоставленном layout; IndexOutOfBoundsException - если offset > byteSize() - layout.byteSize() или offset < 0; IllegalArgumentException - если этот сегмент является только для чтения

get

MemorySegment get(AddressLayout layout, long offset)

Считывает адрес из этого сегмента по заданному смещению, используя заданный layout. Прочитанный адрес оборачивается в собственный сегмент, связанный с глобальной областью видимости. В обычных условиях размер возвращаемого сегмента равен 0. Однако, если предоставленный layout адреса имеет целевой layout T, то размер возвращаемого сегмента устанавливается в T.byteSize().

Параметры:: layout - layout области памяти, которая будет считана; offset - смещение в байтах (относительно адреса этого сегмента), по которому будет выполняться операция доступа
Возвращает:: собственный сегмент, содержащий адрес, прочитанный из этого сегмента
Исключения:: IllegalStateException - если область видимости (scope), связанная с этим сегментом, не активна; WrongThreadException - если этот метод вызывается из потока T, так что isAccessibleBy(T) == false; IllegalArgumentException - если операция доступа несовместима с ограничением выравнивания в предоставленном layout; IllegalArgumentException - если предоставленный layout адреса имеет целевой layout T, и адрес возвращаемого сегмента несовместим с ограничением выравнивания в T; IndexOutOfBoundsException - если offset > byteSize() - layout.byteSize() или offset < 0

set

void set(AddressLayout layout, long offset, MemorySegment value)

Записывает адрес в этот сегмент по заданному смещению, используя заданный layout.

Параметры:: layout - layout области памяти, которая будет записана; offset - смещение в байтах (относительно адреса этого сегмента), по которому будет выполняться операция доступа.; value - значение адреса, которое будет записано.
Исключения:: IllegalStateException - если область видимости (scope), связанная с этим сегментом, не активна; WrongThreadException - если этот метод вызывается из потока T, так что isAccessibleBy(T) == false; IllegalArgumentException - если операция доступа несовместима с ограничением выравнивания в предоставленном layout; IndexOutOfBoundsException - если offset > byteSize() - layout.byteSize() или offset < 0; IllegalArgumentException - если value не является собственным сегментом; IllegalArgumentException - если этот сегмент является только для чтения

getAtIndex

byte getAtIndex(ValueLayout.OfByte layout, long index)

Считывает байт из этого сегмента по заданному индексу, масштабированному по размеру заданного layout.

Параметры:: layout - layout области памяти, которая будет считана; index - логический индекс. Смещение в байтах (относительно адреса этого сегмента), по которому будет выполняться операция доступа, может быть выражено как (index * layout.byteSize()).
Возвращает:: значение байта, прочитанное из этого сегмента
Исключения:: IllegalStateException - если область видимости (scope), связанная с этим сегментом, не активна; WrongThreadException - если этот метод вызывается из потока T, так что isAccessibleBy(T) == false; IllegalArgumentException - если операция доступа несовместима с ограничением выравнивания в предоставленном layout; IllegalArgumentException - если layout.byteAlignment() > layout.byteSize(); IndexOutOfBoundsException - если index * layout.byteSize() переполняется; IndexOutOfBoundsException - если index * layout.byteSize() > byteSize() - layout.byteSize() или index < 0

getAtIndex

boolean getAtIndex(ValueLayout.OfBoolean layout, long index)

Считывает булево значение из этого сегмента по заданному индексу, масштабированному по размеру заданного layout.

Параметры:: layout - layout области памяти, которая будет считана; index - логический индекс. Смещение в байтах (относительно адреса этого сегмента), по которому будет выполняться операция доступа, может быть выражено как (index * layout.byteSize()).
Возвращает:: булево значение, прочитанное из этого сегмента
Исключения:: IllegalStateException - если область видимости (scope), связанная с этим сегментом, не активна; WrongThreadException - если этот метод вызывается из потока T, так что isAccessibleBy(T) == false; IllegalArgumentException - если операция доступа несовместима с ограничением выравнивания в предоставленном layout; IllegalArgumentException - если layout.byteAlignment() > layout.byteSize(); IndexOutOfBoundsException - если index * layout.byteSize() переполняется; IndexOutOfBoundsException - если index * layout.byteSize() > byteSize() - layout.byteSize() или index < 0

getAtIndex

char getAtIndex(ValueLayout.OfChar layout, long index)

Считывает символ char из этого сегмента по заданному индексу, масштабированному по размеру заданного layout.

Параметры:: layout - layout области памяти, которая будет считана; index - логический индекс. Смещение в байтах (относительно адреса этого сегмента), по которому будет выполняться операция доступа, может быть выражено как (index * layout.byteSize()).
Возвращает:: значение char, прочитанное из этого сегмента
Исключения:: IllegalStateException - если область видимости (scope), связанная с этим сегментом, не активна; WrongThreadException - если этот метод вызывается из потока T, так что isAccessibleBy(T) == false; IllegalArgumentException - если операция доступа несовместима с ограничением выравнивания в предоставленном layout; IllegalArgumentException - если layout.byteAlignment() > layout.byteSize(); IndexOutOfBoundsException - если index * layout.byteSize() переполняется; IndexOutOfBoundsException - если index * layout.byteSize() > byteSize() - layout.byteSize() или index < 0

setAtIndex

void setAtIndex(ValueLayout.OfChar layout, long index, char value)

Записывает символ char в этот сегмент по заданному индексу, масштабированному по размеру заданного layout.

Параметры:: layout - layout области памяти, которая будет записана; index - логический индекс. Смещение в байтах (относительно адреса этого сегмента), по которому будет выполняться операция доступа, может быть выражено как (index * layout.byteSize()).; value - значение char, которое будет записано
Исключения:: IllegalStateException - если область видимости (scope), связанная с этим сегментом, не активна; WrongThreadException - если этот метод вызывается из потока T, так что isAccessibleBy(T) == false; IllegalArgumentException - если операция доступа несовместима с ограничением выравнивания в предоставленном layout; IllegalArgumentException - если layout.byteAlignment() > layout.byteSize(); IndexOutOfBoundsException - если index * layout.byteSize() переполняется; IndexOutOfBoundsException - если index * layout.byteSize() > byteSize() - layout.byteSize() или index < 0; IllegalArgumentException - если этот сегмент является только для чтения

getAtIndex

short getAtIndex(ValueLayout.OfShort layout, long index)

Читает короткое значение из этого сегмента по заданному индексу, масштабированному по размеру заданного макета.

Параметры:: layout - макет области памяти, которая будет прочитана; index - логический индекс. Смещение в байтах (относительно адреса этого сегмента), по которому будет выполнена операция доступа, может быть выражено как (index * layout.byteSize()).
Возвращает:: короткое значение, прочитанное из этого сегмента
Исключения:: IllegalStateException - если область видимости, связанная с этим сегментом, не активна; WrongThreadException - если этот метод вызывается из потока T, такого что isAccessibleBy(T) == false; IllegalArgumentException - если операция доступа несовместима с ограничением выравнивания в предоставленном макете; IllegalArgumentException - если layout.byteAlignment() > layout.byteSize(); IndexOutOfBoundsException - если index * layout.byteSize() переполняется; IndexOutOfBoundsException - если index * layout.byteSize() > byteSize() - layout.byteSize() или index < 0

setAtIndex

void setAtIndex(ValueLayout.OfByte layout, long index, byte value)

Записывает байт в этот сегмент по заданному индексу, масштабированному по размеру заданного макета.

Параметры:: layout - макет области памяти, которая будет записана; index - логический индекс. Смещение в байтах (относительно адреса этого сегмента), по которому будет выполнена операция доступа, может быть выражено как (index * layout.byteSize()).; value - короткое значение, которое будет записано
Исключения:: IllegalStateException - если область видимости, связанная с этим сегментом, не активна; WrongThreadException - если этот метод вызывается из потока T, такого что isAccessibleBy(T) == false; IllegalArgumentException - если операция доступа несовместима с ограничением выравнивания в предоставленном макете; IllegalArgumentException - если layout.byteAlignment() > layout.byteSize(); IndexOutOfBoundsException - если index * layout.byteSize() переполняется; IndexOutOfBoundsException - если index * layout.byteSize() > byteSize() - layout.byteSize() или index < 0; IllegalArgumentException - если этот сегмент является только для чтения

setAtIndex

void setAtIndex(ValueLayout.OfBoolean layout, long index, boolean value)

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

Параметры:: layout - макет области памяти, которая будет записана; index - логический индекс. Смещение в байтах (относительно адреса этого сегмента), по которому будет выполнена операция доступа, может быть выражено как (index * layout.byteSize()).; value - короткое значение, которое будет записано
Исключения:: IllegalStateException - если область видимости, связанная с этим сегментом, не активна; WrongThreadException - если этот метод вызывается из потока T, такого что isAccessibleBy(T) == false; IllegalArgumentException - если операция доступа несовместима с ограничением выравнивания в предоставленном макете; IllegalArgumentException - если layout.byteAlignment() > layout.byteSize(); IndexOutOfBoundsException - если index * layout.byteSize() переполняется; IndexOutOfBoundsException - если index * layout.byteSize() > byteSize() - layout.byteSize() или index < 0; IllegalArgumentException - если этот сегмент является только для чтения

setAtIndex

void setAtIndex(ValueLayout.OfShort layout, long index, short value)

Записывает короткое значение в этот сегмент по заданному индексу, масштабированному по размеру заданного макета.

Параметры:: layout - макет области памяти, которая будет записана; index - логический индекс. Смещение в байтах (относительно адреса этого сегмента), по которому будет выполнена операция доступа, может быть выражено как (index * layout.byteSize()).; value - короткое значение, которое будет записано
Исключения:: IllegalStateException - если область видимости, связанная с этим сегментом, не активна; WrongThreadException - если этот метод вызывается из потока T, такого что isAccessibleBy(T) == false; IllegalArgumentException - если операция доступа несовместима с ограничением выравнивания в предоставленном макете; IllegalArgumentException - если layout.byteAlignment() > layout.byteSize(); IndexOutOfBoundsException - если index * layout.byteSize() переполняется; IndexOutOfBoundsException - если index * layout.byteSize() > byteSize() - layout.byteSize() или index < 0; IllegalArgumentException - если этот сегмент является только для чтения

getAtIndex

int getAtIndex(ValueLayout.OfInt layout, long index)

Читает целое число из этого сегмента по заданному индексу, масштабированному по размеру заданного макета.

Параметры:: layout - макет области памяти, которая будет прочитана.; index - логический индекс. Смещение в байтах (относительно адреса этого сегмента), по которому будет выполнена операция доступа, может быть выражено как (index * layout.byteSize()).
Возвращает:: целое число, прочитанное из этого сегмента
Исключения:: IllegalStateException - если область видимости, связанная с этим сегментом, не активна; WrongThreadException - если этот метод вызывается из потока T, такого что isAccessibleBy(T) == false; IllegalArgumentException - если операция доступа несовместима с ограничением выравнивания в предоставленном макете; IllegalArgumentException - если layout.byteAlignment() > layout.byteSize(); IndexOutOfBoundsException - если index * layout.byteSize() переполняется; IndexOutOfBoundsException - если index * layout.byteSize() > byteSize() - layout.byteSize() или index < 0

setAtIndex

void setAtIndex(ValueLayout.OfInt layout, long index, int value)

Записывает целое число в этот сегмент по заданному индексу, масштабированному по размеру заданного макета.

Параметры:: layout - макет области памяти, которая будет записана; index - логический индекс. Смещение в байтах (относительно адреса этого сегмента), по которому будет выполнена операция доступа, может быть выражено как (index * layout.byteSize()).; value - целое число, которое будет записано
Исключения:: IllegalStateException - если область видимости, связанная с этим сегментом, не активна; WrongThreadException - если этот метод вызывается из потока T, такого что isAccessibleBy(T) == false; IllegalArgumentException - если операция доступа несовместима с ограничением выравнивания в предоставленном макете; IllegalArgumentException - если layout.byteAlignment() > layout.byteSize(); IndexOutOfBoundsException - если index * layout.byteSize() переполняется; IndexOutOfBoundsException - если index * layout.byteSize() > byteSize() - layout.byteSize() или index < 0; IllegalArgumentException - если этот сегмент является только для чтения

getAtIndex

float getAtIndex(ValueLayout.OfFloat layout, long index)

Читает число с плавающей точкой из этого сегмента по заданному индексу, масштабированному по размеру заданного макета.

Параметры:: layout - макет области памяти, которая будет прочитана; index - логический индекс. Смещение в байтах (относительно адреса этого сегмента), по которому будет выполнена операция доступа, может быть выражено как (index * layout.byteSize()).
Возвращает:: число с плавающей точкой, прочитанное из этого сегмента
Исключения:: IllegalStateException - если область видимости, связанная с этим сегментом, не активна; WrongThreadException - если этот метод вызывается из потока T, такого что isAccessibleBy(T) == false; IllegalArgumentException - если операция доступа несовместима с ограничением выравнивания в предоставленном макете; IllegalArgumentException - если layout.byteAlignment() > layout.byteSize(); IndexOutOfBoundsException - если index * layout.byteSize() переполняется; IndexOutOfBoundsException - если index * layout.byteSize() > byteSize() - layout.byteSize() или index < 0

setAtIndex

void setAtIndex(ValueLayout.OfFloat layout, long index, float value)

Записывает значение float в этот сегмент по заданному индексу, масштабируя его с помощью заданного размера макета.

Параметры:: layout - макет области памяти, которую нужно записать; index - логический индекс. Смещение в байтах (относительно адреса этого сегмента), в котором будет выполняться операция доступа, может быть выражено как (index * layout.byteSize()).; value - значение float, которое нужно записать
Исключения:: IllegalStateException - если область видимости (scope), связанная с этим сегментом, не является активной; WrongThreadException - если этот метод вызван из потока T, таким образом, что isAccessibleBy(T) == false; IllegalArgumentException - если операция доступа несовместима с ограничением выравнивания в предоставленном макете; IllegalArgumentException - если layout.byteAlignment() > layout.byteSize(); IndexOutOfBoundsException - если index * layout.byteSize() переполняется; IndexOutOfBoundsException - если index * layout.byteSize() > byteSize() - layout.byteSize() или index < 0; IllegalArgumentException - если этот сегмент является только для чтения

getAtIndex

long getAtIndex(ValueLayout.OfLong layout, long index)

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

Параметры:: layout - макет области памяти, которую нужно считать; index - логический индекс. Смещение в байтах (относительно адреса этого сегмента), в котором будет выполняться операция доступа, может быть выражено как (index * layout.byteSize()).
Возвращает:: значение long, считаное из этого сегмента
Исключения:: IllegalStateException - если область видимости (scope), связанная с этим сегментом, не является активной; WrongThreadException - если этот метод вызван из потока T, таким образом, что isAccessibleBy(T) == false; IllegalArgumentException - если операция доступа несовместима с ограничением выравнивания в предоставленном макете; IllegalArgumentException - если layout.byteAlignment() > layout.byteSize(); IndexOutOfBoundsException - если index * layout.byteSize() переполняется; IndexOutOfBoundsException - если index * layout.byteSize() > byteSize() - layout.byteSize() или index < 0

setAtIndex

void setAtIndex(ValueLayout.OfLong layout, long index, long value)

Записывает значение long в этот сегмент по заданному индексу, масштабируя его с помощью заданного размера макета.

Параметры:: layout - макет области памяти, которую нужно записать; index - логический индекс. Смещение в байтах (относительно адреса этого сегмента), в котором будет выполняться операция доступа, может быть выражено как (index * layout.byteSize()).; value - значение long, которое нужно записать
Исключения:: IllegalStateException - если область видимости (scope), связанная с этим сегментом, не является активной; WrongThreadException - если этот метод вызван из потока T, таким образом, что isAccessibleBy(T) == false; IllegalArgumentException - если операция доступа несовместима с ограничением выравнивания в предоставленном макете; IllegalArgumentException - если layout.byteAlignment() > layout.byteSize(); IndexOutOfBoundsException - если index * layout.byteSize() переполняется; IndexOutOfBoundsException - если index * layout.byteSize() > byteSize() - layout.byteSize() или index < 0; IllegalArgumentException - если этот сегмент является только для чтения

getAtIndex

double getAtIndex(ValueLayout.OfDouble layout, long index)

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

Параметры:: layout - макет области памяти, которую нужно считать; index - логический индекс. Смещение в байтах (относительно адреса этого сегмента), в котором будет выполняться операция доступа, может быть выражено как (index * layout.byteSize()).
Возвращает:: значение double, считаное из этого сегмента
Исключения:: IllegalStateException - если область видимости (scope), связанная с этим сегментом, не является активной; WrongThreadException - если этот метод вызван из потока T, таким образом, что isAccessibleBy(T) == false; IllegalArgumentException - если операция доступа несовместима с ограничением выравнивания в предоставленном макете; IllegalArgumentException - если layout.byteAlignment() > layout.byteSize(); IndexOutOfBoundsException - если index * layout.byteSize() переполняется; IndexOutOfBoundsException - если index * layout.byteSize() > byteSize() - layout.byteSize() или index < 0

setAtIndex

void setAtIndex(ValueLayout.OfDouble layout, long index, double value)

Записывает значение double в этот сегмент по заданному индексу, масштабируя его с помощью заданного размера макета.

Параметры:: layout - макет области памяти, которую нужно записать; index - логический индекс. Смещение в байтах (относительно адреса этого сегмента), в котором будет выполняться операция доступа, может быть выражено как (index * layout.byteSize()).; value - значение double, которое нужно записать
Исключения:: IllegalStateException - если область видимости (scope), связанная с этим сегментом, не является активной; WrongThreadException - если этот метод вызван из потока T, таким образом, что isAccessibleBy(T) == false; IllegalArgumentException - если операция доступа несовместима с ограничением выравнивания в предоставленном макете; IllegalArgumentException - если layout.byteAlignment() > layout.byteSize(); IndexOutOfBoundsException - если index * layout.byteSize() переполняется; IndexOutOfBoundsException - если index * layout.byteSize() > byteSize() - layout.byteSize() или index < 0; IllegalArgumentException - если этот сегмент является только для чтения

getAtIndex

MemorySegment getAtIndex(AddressLayout layout, long index)

Считывает адрес из этого сегмента по заданному индексу, масштабируя его с помощью заданного размера макета. Считанный адрес упакован в нативный сегмент, связанный с глобальной областью видимости. В нормальных условиях размер возвращаемого сегмента равен 0. Однако, если предоставленный макет адреса имеет целевой макет T, то размер возвращаемого сегмента равен T.byteSize().

Параметры:: layout - макет области памяти, которую нужно считать; index - логический индекс. Смещение в байтах (относительно адреса этого сегмента), в котором будет выполняться операция доступа, может быть выражено как (index * layout.byteSize()).
Возвращает:: нативный сегмент, содержащий считанный адрес
Исключения:: IllegalStateException - если область видимости (scope), связанная с этим сегментом, не является активной; WrongThreadException - если этот метод вызван из потока T, таким образом, что isAccessibleBy(T) == false; IllegalArgumentException - если операция доступа несовместима с ограничением выравнивания в предоставленном макете.; IllegalArgumentException - если layout.byteAlignment() > layout.byteSize(); IllegalArgumentException - если предоставленный макет адреса имеет целевой макет T, и адрес возвращаемого сегмента несовместим с ограничением выравнивания в T; IndexOutOfBoundsException - если index * layout.byteSize() переполняется; IndexOutOfBoundsException - если index * layout.byteSize() > byteSize() - layout.byteSize() или index < 0

setAtIndex

void setAtIndex(AddressLayout layout, long index, MemorySegment value)

Записывает адрес в этот сегмент по заданному индексу, масштабируя его с помощью заданного размера макета.

Параметры:: layout - макет области памяти, которую нужно записать; index - логический индекс. Смещение в байтах (относительно адреса этого сегмента), в котором будет выполняться операция доступа, может быть выражено как (index * layout.byteSize()).; value - значение адреса, которое нужно записать
Исключения:: IllegalStateException - если область видимости (scope), связанная с этим сегментом, не является активной; WrongThreadException - если этот метод вызван из потока T, таким образом, что isAccessibleBy(T) == false; IllegalArgumentException - если операция доступа несовместима с ограничением выравнивания в предоставленном макете.; IllegalArgumentException - если layout.byteAlignment() > layout.byteSize(); IndexOutOfBoundsException - если index * layout.byteSize() переполняется; IndexOutOfBoundsException - если index * layout.byteSize() > byteSize() - layout.byteSize() или index < 0; IllegalArgumentException - если value не является нативным сегментом; IllegalArgumentException - если этот сегмент является только для чтения

equals

boolean equals(Object that)

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

Более конкретно, для двух сегментов s1 и s2, чтобы считаться равными, должны выполняться все следующие условия:

s1.heapBase().equals(s2.heapBase()), то есть два сегмента должны быть одного типа; либо оба являются нативными сегментами, поддерживаемыми вне кучи памяти, либо оба поддерживаются одним и тем же объектом Java на куче;
s1.address() == s2.address(), то есть адрес двух сегментов должен быть одинаковым. Это означает, что два сегмента либо ссылаются на одно и то же местоположение в некотором внекучевом регионе, либо они ссылаются на один и тот же смещение внутри своего связанного объекта Java.

Overrides:

equals в классе Object

API Note:

Этот метод не выполняет структурное сравнение содержимого двух сегментов памяти. Клиенты могут сравнивать сегменты памяти структурно, используя метод mismatch(MemorySegment) вместо этого. Обратите внимание, что этот метод не сравнивает временные и пространственные границы двух сегментов. Таким образом, он подходит для проверки того, имеют ли два сегмента один и тот же адрес.

Parameters:

that - объект, который нужно сравнить на равенство с этим сегментом памяти

Returns:

true, если указанный объект равен этому сегменту памяти

See Also:

hashCode

int hashCode()

Возвращает значение хэш-кода для этого сегмента памяти.

Overrides:

hashCode в классе Object

Returns:

значение хэш-кода для этого сегмента памяти

See Also:

copy

static void copy(MemorySegment srcSegment, ValueLayout srcLayout, long srcOffset, Object dstArray, int dstIndex, int elementCount)

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

Поддерживаемые типы массивов: byte[], char[], short[], int[], float[], long[] и double[].

Parameters:: srcSegment - исходный сегмент; srcLayout - макет элемента источника. Если порядок байтов, связанный с макетом, отличается от родного порядка, для каждого элемента массива будет выполнена операция перестановки байтов; srcOffset - начальное смещение в байтах исходного сегмента; dstArray - целевой массив; dstIndex - начальный индекс целевого массива; elementCount - количество элементов массива, которые нужно скопировать
Throws:: IllegalStateException - если область действия, связанная с srcSegment, не активна; WrongThreadException - если этот метод вызывается из потока T, таком, что srcSegment.isAccessibleBy(T) == false; IllegalArgumentException - если dstArray не является массивом или если это массив, но его тип не поддерживается; IllegalArgumentException - если тип компонента целевого массива не соответствует srcLayout.carrier(); IllegalArgumentException - если offset несовместим с ограничением выравнивания в макете элемента источника; IllegalArgumentException - если srcLayout.byteAlignment() > srcLayout.byteSize(); IndexOutOfBoundsException - если elementCount * srcLayout.byteSize() переполняется; IndexOutOfBoundsException - если srcOffset > srcSegment.byteSize() - (elementCount * srcLayout.byteSize()); IndexOutOfBoundsException - если dstIndex > dstArray.length - elementCount; IndexOutOfBoundsException - если любой из srcOffset, dstIndex или elementCount является < 0

copy

static void copy(Object srcArray, int srcIndex, MemorySegment dstSegment, ValueLayout dstLayout, long dstOffset, int elementCount)

Копирует определенное количество элементов из исходного массива в целевой сегмент памяти.

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

Поддерживаемые типы массивов: byte[], char[], short[], int[], float[], long[] и double[].

Parameters:: srcArray - исходный массив; srcIndex - начальный индекс исходного массива; dstSegment - целевой сегмент; dstLayout - макет элемента назначения. Если порядок байтов, связанный с макетом, отличается от родного порядка, для каждого элемента массива будет выполнена операция перестановки байтов.; dstOffset - начальное смещение в байтах целевого сегмента; elementCount - количество элементов массива, которые нужно скопировать
Throws:: IllegalStateException - если область действия, связанная с dstSegment, не активна; WrongThreadException - если этот метод вызывается из потока T, таком, что dstSegment.isAccessibleBy(T) == false; IllegalArgumentException - если srcArray не является массивом или если это массив, но его тип не поддерживается; IllegalArgumentException - если тип компонента исходного массива не соответствует srcLayout.carrier(); IllegalArgumentException - если offset несовместим с ограничением выравнивания в макете элемента источника; IllegalArgumentException - если dstLayout.byteAlignment() > dstLayout.byteSize(); IllegalArgumentException - если elementCount * dstLayout.byteSize() является только для чтения; IndexOutOfBoundsException - если dstSegment переполняется; IndexOutOfBoundsException - если dstOffset > dstSegment.byteSize() - (elementCount * dstLayout.byteSize()); IndexOutOfBoundsException - если srcIndex > srcArray.length - elementCount; IndexOutOfBoundsException - если любой из srcIndex, dstOffset или elementCount является < 0

mismatch

static long mismatch(MemorySegment srcSegment, long srcFromOffset, long srcToOffset, MemorySegment dstSegment, long dstFromOffset, long dstToOffset)

Находит и возвращает относительное смещение в байтах первого несовпадения между исходным и целевыми сегментами. Более конкретно, байты со смещениями srcFromOffset по srcToOffset - 1 в исходном сегменте сравниваются с байтами со смещениями dstFromOffset по dstToOffset - 1 в целевом сегменте.

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

Parameters:

srcSegment - исходный сегмент.

srcFromOffset - смещение (включительно) первого байта в исходном сегменте, подлежащего проверке

srcToOffset - смещение (исключительно) последнего байта в исходном сегменте, подлежащего проверке

dstSegment - целевой сегмент

dstFromOffset - смещение (включительно) первого байта в целевом сегменте, подлежащего проверке

dstToOffset - смещение (исключительно) последнего байта в целевом сегменте, подлежащего проверке

Returns:

относительное смещение в байтах первого несовпадения между исходным и целевым сегментами, в противном случае -1, если несовпадений нет

Throws:

IllegalStateException - если область действия, связанная с srcSegment, не активна

WrongThreadException - если этот метод вызывается из потока T, таком, что srcSegment.isAccessibleBy(T) == false

IllegalStateException - если область действия, связанная с dstSegment, не активна

WrongThreadException - если этот метод вызывается из потока T, таком, что dstSegment.isAccessibleBy(T) == false

IndexOutOfBoundsException - если srcFromOffset < 0, srcToOffset < srcFromOffset или srcToOffset > srcSegment.byteSize()

IndexOutOfBoundsException - если dstFromOffset < 0, dstToOffset < dstFromOffset или dstToOffset > dstSegment.byteSize()

See Also:

© 1993, 2025, Oracle and/or its affiliates. All rights reserved.
Documentation extracted from Debian's OpenJDK Development Kit package.
Licensed under the GNU General Public License, version 2, with the Classpath Exception.
Various third party code in OpenJDK is licensed under different licenses (see Debian package).
Java and OpenJDK are trademarks or registered trademarks of Oracle and/or its affiliates.
https://download.java.net/java/early_access/jdk24/docs/api/java.base/java/lang/foreign/MemorySegment.html