すべてのスーパー・インタフェース:: Addressable, AutoCloseable

public interface MemorySegment extends Addressable, AutoCloseable

メモリー・セグメントは、連続するメモリー・リージョンをモデル化します。メモリー・セグメントは、空間境界および時間的境界の両方に関連付けられます。空間境界は、メモリー・セグメントに対するメモリー・アクセス操作が、「外部」にアクセスされるメモリー・セグメントの境界よりも少ないメモリーのロケーションに影響を与えないようにします。一時境界を使用すると、メモリー・セグメントが(close()を参照してください)でクローズされた後に、セグメントに対するメモリー・アクセス操作を実行できなくなります。

このインタフェースのすべての実装はvalue-basedである必要があります。プログラマは、同等のインスタンスを交換可能として扱う必要があり、同期にインスタンスを使用しないでください。そうしないと、予期しない動作が発生する可能性があります。たとえば、将来のリリースでは、同期が失敗する可能性があります。比較する場合は、equalsメソッドを使用することをお薦めします。

非プラットフォーム・クラスは、MemorySegmentを直接実装することはできません。

特に指定がないかぎり、null引数、またはこのクラスのメソッドに1つ以上のnull要素を含む配列引数を渡すと、NullPointerExceptionがスローされます。

メモリー・セグメントの構築

メモリー・セグメントを取得する方法は複数あります。最初に、(allocateNative(MemoryLayout)、allocateNative(long)およびallocateNative(long, long)を参照してください。)から提供される数多くのファクトリ・メソッドのいずれかを使用して、ヒープ外メモリーによってバックアップされるメモリー・セグメントを割り当てることができます。この方法で取得されたメモリー・セグメントは「ネイティブ・メモリー・セグメント」と呼ばれます。

また、用意されているファクトリ・メソッド(e.g. ofArray(int[]))のいずれかを使用して、既存のヒープ割当てJava配列に連動するメモリー・セグメントを取得することもできます。この方法で取得されたメモリー・セグメントは「配列メモリー・セグメント」と呼ばれます。

ofByteBuffer(ByteBuffer)ファクトリ・メソッドを使用して、既存のJavaバイト・バッファ(ByteBufferを参照してください)に連動するメモリー・セグメントを取得できます。この方法で取得されたメモリー・セグメントは「バッファ・メモリー・セグメント」と呼ばれます。バッファ・メモリー・セグメントは、セグメントが関連付けられているバイト・バッファ・インスタンスの特性に応じて、システム固有のメモリー(ネイティブ・メモリー・セグメントの場合と同様)またはヒープ・メモリー(配列メモリー・セグメントの場合と同様)によってバッキングされる場合があります。たとえば、ByteBuffer.allocateDirect(int)メソッドで作成されたバイト・バッファから取得されたバッファ・メモリー・セグメントは、ネイティブ・メモリーによってバックアップされます。

最後に、ファクトリ・メソッドmapFile(Path, long, long, FileChannel.MapMode)を使用して、メモリー・マップ・ファイルでバックアップされたメモリー・セグメントを取得することもできます。このようなメモリー・セグメントは「マッピングされたメモリー・セグメント」と呼ばれ、マップされたメモリー・セグメントは基礎となるファイル記述子に関連付けられます。マップされたメモリー・セグメントの演算の詳細は、MappedMemorySegmentsクラスを参照してください。

配列セグメントおよびバッファ・セグメントは、既存のメモリー・リージョン全体で効果的に「ビュー」となり、それらから導出されたセグメントのライフサイクルを上回り、他のクライアントから直接(配列アクセスやByteBuffer APIの直接使用など)を操作することもできます。そのため、配列セグメントまたはバッファ・セグメントを共有することは可能ですが、そのようなセグメントに関連付けられた基礎となるメモリー・ソースがアクセス不可能なままであること、および同時に複数のセグメントによって別名が設定されないことを確認するために、クライアントは追加の注意を払うことを強くお薦めします - たとえば、配列またはバッファ・セグメントの内容が同時に変更されないようにします。

明示的な割当て解除

メモリー・セグメントは明示的に(close()を参照してください)でクローズされます。セグメントがクローズされると、そのセグメントはaliveではなくなります(isAlive()を参照してください。セグメント(またはそれから導出されたMemoryAddressインスタンス)に対する後続の操作はIllegalStateExceptionで失敗します。

セグメントをクローズすると、考慮されるメモリー・セグメントの種類に応じて、指定されたセグメントに関連付けられた基礎となるメモリー・リソースの解放がトリガーされる場合があります:

ネイティブ・メモリー・セグメントを閉じると、「解放」のネイティブ・メモリーがそのセグメントに関連付けられます。
マップされたメモリー・セグメントを閉じると、バッキング・マップのファイルがマップ解除されます
バッファを閉じる、またはヒープ・セグメントに副次効果がない(セグメントを「生きていない」 (isAlive()を参照してください)とマークする以外)。また、バッファおよびヒープ・セグメントは元のバッファまたは配列インスタンスへの強力な参照を維持しているため、クライアントはこれらのセグメントが適時に破棄されるようにする必要があります。したがって、ガベージ・コレクションによって基礎となるオブジェクトの再利用を妨げないようにする必要があります。

アクセス・モード

メモリー・セグメントでは、ゼロ個以上の「アクセス・モード」がサポートされます。サポートされているアクセス・モードは、READ、WRITE、CLOSE、SHAREおよびHANDOFFです。セグメントでサポートされているアクセス・モードのセットによって、そのセグメントでサポートされている一連の操作が変更されます。たとえば、CLOSEアクセス・モードをサポートしていないセグメントでclose()をコールしようとすると、例外が発生します。

サポートされているアクセス・モードのセットは、より厳密な(「より少ない」アクセス・モードのサポート)にのみできます。つまり、セグメントの作成者がセグメントへのアクセス方法を制御する必要がある場合は、セグメントを他のクライアントと共有する前に、セグメントでサポートされるアクセス・モードのセットを制限することをお薦めします。

メモリー・セグメント・ビュー

メモリー・セグメントは「ビュー」をサポートしています。たとえば、次のようにメモリー・セグメントの「不変」ビューを作成することで、サポートされているアクセス・モードのセットを変更できます:


MemorySegment segment = ...
MemorySegment roSegment = segment.withAccessModes(segment.accessModes() & ~WRITE);

空間境界が元のセグメント(asSlice(long, long)を参照してください)のものより厳密であるビューを作成することもできます。

元のセグメントの一時的境界はビューによって継承されます。つまり、分割されたビューなどのセグメント・ビューを閉じると、元のセグメントが閉じます。複数のクライアント間でビューを共有する場合は、特別な注意を払う必要があります。別のアクターによるセグメントの早期クローズからクライアント自体を保護する場合は、別のクライアントとビューを共有する前に、サポートされているアクセス・モードのセットからCLOSEを削除するなどの保護対策を講じる必要があります。

既存のコードとの相互運用性を確保するために、バイト・バッファ・ビューはメモリー・セグメント(asByteBuffer()を参照してください)から取得できます。これは、たとえばByteBuffer APIを使用したままにする必要があるクライアントでは有用ですが、大量のメモリー・セグメントで操作する必要があります。このような方法で取得されたバイト・バッファでは、元のメモリー・セグメントに関連付けられた空間および一時的なアクセス制限がサポートされます。

スレッド制限

メモリー・セグメントは、強力なスレッド定義の保証をサポートしています。作成時に、「所有者スレッド」に割り当てられるのは通常、作成操作を開始したスレッドです。作成後は、所有者のスレッドだけがメモリー・セグメント(例:メモリー・セグメントを閉じます)を直接操作したり、メモリー・アクセスのvarハンドルを使用してセグメントに関連する基になるメモリーにアクセスしたりできます。所有者スレッド以外のスレッドからこのような操作を実行しようとすると、実行時に失敗します。

handoff(Thread)メソッドを使用して、メモリー・セグメントのスレッド定義プロパティを変更できます。このメソッドは、close()と同様に、元のセグメントを稼働していない(isAlive()を参照してください)としてマークし、目的のスレッド定義プロパティでnewセグメントを作成する「終端演算」です。 handoff(Thread)をコールできるのは、セグメントに対応するHANDOFFアクセス・モードがある場合のみです。

たとえば、クライアントがセグメントの所有権を別の(known)スレッドに移管する場合は、次のようにします:


MemorySegment segment = ...
MemorySegment aSegment = segment.handoff(threadA);

これにより、元のセグメントは非稼働としてマークされ、所有者スレッドがthreadAである新しいセグメントが返されます。これにより、たとえば、2つのスレッドAとBで、制御された、協調的かつ自由な方法でセグメントを共有できます。(「シリアル・スレッド制限」とも呼ばれる)。

または、share()メソッドを使用してスレッドの所有権を完全に削除できます。これは、セグメントに対応するSHAREアクセス・モードがある場合にのみ可能です。次のコードは、クライアントが共有セグメントを取得する方法を示しています:


MemorySegment segment = ...
MemorySegment sharedSegment = segment.share();

ここでも、元のセグメントは非アライブとしてマークされ、所有者スレッド(例: ownerThread()はnullを返します)を持たない新しいsharedセグメントが返されます。これは、複数のスレッドが同じメモリー・セグメントの内容を同時に(例:パラレル処理の場合)で処理する必要がある場合に役立つことがあります。たとえば、クライアントが共有セグメントからSpliteratorを取得し、それを使用してセグメントをスライスし、複数のスレッドが非結合セグメント・スライスで並行して動作できるようにすることができます。次のコードを使用すると、メモリー・セグメント内のすべてのint値を並列に合計できます:


SequenceLayout SEQUENCE_LAYOUT = MemoryLayout.ofSequence(1024, MemoryLayouts.JAVA_INT);
try (MemorySegment segment = MemorySegment.allocateNative(SEQUENCE_LAYOUT).share()) {
    VarHandle VH_int = SEQUENCE_LAYOUT.elementLayout().varHandle(int.class);
    int sum = StreamSupport.stream(segment.spliterator(SEQUENCE_LAYOUT), true)
                           .mapToInt(s -> (int)VH_int.get(s.address()))
                           .sum();
}

共有されたセグメントは、特定のスレッド(handoff(Thread)の再使用)によって要求できます。実際には、多数のスレッドが同時に同じセグメントの所有権を取得しようとすることができ、そのうちの1つのみが成功することが保証されます。

共有セグメントを使用する場合、クライアントは、セグメントのクローズ中にほかのスレッドがそのセグメントにアクセスしていないことを確認するようにしてください。セグメントのクローズ中に1つ以上のスレッドが同時にセグメントにアクセスしようとすると、アクセスするスレッドとクローズするスレッドの両方で例外が発生する可能性があります。クライアントは、(例:例外がスローされなくなるまでclose()をコールし続ける)を繰り返しクローズしようとしないように注意する必要があります。そのような例外は、セグメントにアクセス/クローズするスレッド間でクライアント・コードに適切な同期がないことを示すものです。

暗黙的な割当て解除

クライアントは、Cleanerに対してメモリー・セグメントを登録して、セグメントがunreachableになったときに、そのセグメントに関連付けられているベースとなるリソースが確実に解放されるようにすることができます。これは、ネイティブ・メモリー・リークを防ぐのに役立ちます。これは、次のようにregisterCleaner(Cleaner)メソッドを使用して実行できます:


MemorySegment segment = ...
MemorySegment gcSegment = segment.registerCleaner(cleaner);

ここでは、元のセグメントは非稼働としてマークされ、新しいセグメントは(戻されたセグメント・セットの所有者スレッドが現在のスレッドの所有者スレッドに設定されています。ownerThread()を参照)で返されます。つまり、新しいセグメントは、registerCleaner(Cleaner)メソッドに提供されるCleanerインスタンスにも登録されます。そのため、明示的に(close()を参照してください)を閉じない場合、新しいセグメントはクリーナによって自動的に閉じられます。

APIのノート:: 将来、Java言語で許可されている場合、MemorySegmentはsealedインタフェースになる可能性があり、明示的に許可されている他のサブタイプ以外のサブクラス化は禁止されます。
実装要件:: このインタフェースの実装は不変、スレッド・セーフ、およびvalue-basedです。

フィールドのサマリー

フィールド

修飾子と型

フィールド

説明

static int

ALL_ACCESS

デフォルトのアクセス・モード。これは、メモリー・セグメントでサポートされているすべてのアクセス・モードの和集合です。

static int

CLOSE

アクセス・モードをクローズします。close()のコールは、このアクセス・モードをサポートするセグメントでサポートされます。

static int

HANDOFF

ハンド・オフ・アクセス・モード。このセグメントは、スレッド所有権変更(handoff(NativeScope)およびhandoff(Thread)を参照)を介したシリアル・スレッド定義をサポートします。

static int

READ

読取りアクセス・モード。読取り操作は、このアクセス・モードをサポートするセグメントでサポートされます。

static int

SHARE

共有アクセス・モード。このセグメントは、所有者スレッド(share()を参照してください)以外のスレッドとの共有をサポートします。

static int

WRITE

書込みアクセス・モード。書込み操作は、このアクセス・モードをサポートするセグメントでサポートされます。
メソッドのサマリー

修飾子と型

メソッド

説明

int

accessModes()

このセグメントに関連付けられた「アクセス・モード」を返します。結果は、READ、WRITE、CLOSE、SHAREおよびHANDOFFからのORed値として表されます。

MemoryAddress

address()

このメモリー・セグメントに関連付けられているベース・メモリー・アドレス。

static MemorySegment

allocateNative(long bytesSize)

指定されたサイズ(バイト単位)のオフ・ヒープ・メモリーの新しく割り当てられたブロックをモデル化する、新しい制限付きネイティブ・メモリー・セグメントを作成します。

static MemorySegment

allocateNative(long bytesSize, long alignmentBytes)

指定されたサイズおよび配置の制約(バイト単位)を使用して、新しく割り当てられたオフ・ヒープ・メモリーのブロックをモデル化する新しい制限付きネイティブ・メモリー・セグメントを作成します。

static MemorySegment

allocateNative(MemoryLayout layout)

指定されたレイアウトで新しく割り当てられたオフ・ヒープ・メモリーのブロックをモデル化する、新しい制限されたネイティブ・メモリー・セグメントを作成します。

ByteBuffer

asByteBuffer()

ByteBufferでこのセグメントをラップします。

default MemorySegment

asSlice(long offset)

ベース・アドレスがこのセグメントのベース・アドレスに指定されたオフセットを加えたものと同じであり、その新しいサイズがこのセグメント・サイズから指定されたオフセットを引いて計算される新しいメモリー・セグメント・ビューを取得します。

MemorySegment

asSlice(long offset, long newSize)

ベース・アドレスがこのセグメントのベース・アドレスと指定されたオフセットに加えて、指定の引数で新しいサイズが指定されている、新しいメモリー・セグメントのビューを取得します。

default MemorySegment

asSlice(MemoryAddress newBase)

ベース・アドレスが指定されたアドレスであり、このセグメント・サイズからこのセグメント(MemoryAddress.segmentOffset(MemorySegment)を参照してください)に相対的なアドレス・オフセットを減算して新しいサイズが計算される新しいメモリー・セグメント・ビューを取得します。

default MemorySegment

asSlice(MemoryAddress newBase, long newSize)

ベース・アドレスが指定されたアドレスであり、新しいサイズが指定された引数で指定されている新しいメモリー・セグメント・ビューを取得します。

long

byteSize()

このメモリー・セグメントのサイズは(バイト単位)です。

void

close()

このメモリー・セグメントを閉じます。

void

copyFrom(MemorySegment src)

指定されたソース・セグメントからこのセグメントへの一括コピーを実行します。

MemorySegment

fill(byte value)

このメモリー・セグメントに値を入力します。

MemorySegment

handoff(Thread thread)

このセグメントと同じベースとなるメモリー・リージョンに連動する新しい制限されたメモリー・セグメントを取得します。

MemorySegment

handoff(NativeScope nativeScope)

このセグメントと同じベースとなるメモリー・リージョンに連動する、指定されたNativeScopeインスタンスによって一時的な境界が制御される新しい制限されたメモリー・セグメントを取得します。

boolean

hasAccessModes(int accessModes)

このセグメントは特定のアクセス・モードのセットをサポートしていますか。

boolean

isAlive()

このセグメントは動作していますか。

boolean

isMapped()

これはマップ済セグメントですか?

static MemorySegment

mapFile(Path path, long bytesOffset, long bytesSize, FileChannel.MapMode mapMode)

指定されたパスからファイルのメモリー・マップ・リージョンをモデル化する、新しい制限付きマップ・メモリー・セグメントを作成します。

long

mismatch(MemorySegment other)

このセグメントと指定された他のセグメント間の最初の不一致のオフセットをバイト単位で検索して返します。

static MemorySegment

ofArray(byte[] arr)

指定されたヒープ割当てのバイト配列に関連付けられたメモリーをモデル化する新しい制限付き配列メモリー・セグメントを作成します。

static MemorySegment

ofArray(char[] arr)

指定されたヒープ割当てのchar配列に関連付けられたメモリーをモデル化する新しい制限付き配列メモリー・セグメントを作成します。

static MemorySegment

ofArray(double[] arr)

指定されたヒープ割当てのdouble配列に関連付けられたメモリーをモデル化する新しい制限付き配列メモリー・セグメントを作成します。

static MemorySegment

ofArray(float[] arr)

指定されたヒープ割当てのfloat配列に関連付けられたメモリーをモデル化する新しい制限付き配列メモリー・セグメントを作成します。

static MemorySegment

ofArray(int[] arr)

指定されたヒープ割当てのint配列に関連付けられたメモリーをモデル化する新しい制限付き配列メモリー・セグメントを作成します。

static MemorySegment

ofArray(long[] arr)

指定されたヒープ割当てのlong配列に関連付けられたメモリーをモデル化する新しい制限付き配列メモリー・セグメントを作成します。

static MemorySegment

ofArray(short[] arr)

指定されたヒープ割当てのshort配列に関連付けられたメモリーをモデル化する新しい制限付き配列メモリー・セグメントを作成します。

static MemorySegment

ofByteBuffer(ByteBuffer bb)

指定されたbyteバッファに関連付けられたメモリーをモデル化する、新しい制限付きバッファ・メモリー・セグメントを作成します。

static MemorySegment

ofNativeRestricted()

ベース・アドレスがMemoryAddress.NULLで、サイズがLong.MAX_VALUEである共有ネイティブ・メモリー・セグメントを返します。

Thread

ownerThread()

このセグメントを所有しているスレッド。

MemorySegment

registerCleaner(Cleaner cleaner)

このメモリー・セグメント・インスタンスをCleanerオブジェクトに対して登録するには、このセグメントと同じ基礎となるメモリー・リージョンに連動する新しいメモリー・セグメントを戻します。

MemorySegment

share()

このセグメントと同じベースとなるメモリー・リージョンに連動する新しい共有メモリー・セグメントを取得します。

Spliterator<MemorySegment>

spliterator(SequenceLayout layout)

このメモリー・セグメントのスプリッテレータを返します。

byte[]

toByteArray()

このメモリー・セグメントの内容を新しいバイト配列にコピーします。

char[]

toCharArray()

このメモリー・セグメントの内容を新しいchar配列にコピーします。

double[]

toDoubleArray()

このメモリー・セグメントの内容を新しいdouble配列にコピーします。

float[]

toFloatArray()

このメモリー・セグメントの内容を新しいfloat配列にコピーします。

int[]

toIntArray()

このメモリー・セグメントの内容を新しいint配列にコピーします。

long[]

toLongArray()

このメモリー・セグメントの内容を新しいlong配列にコピーします。

short[]

toShortArray()

このメモリー・セグメントの内容を新しいshort配列にコピーします。

MemorySegment

withAccessModes(int accessModes)

特定の「アクセス・モード」を持つセグメント・ビューを取得します。

フィールド詳細
- READ
  
  static final int READ
  
  読取りアクセス・モード。読取り操作は、このアクセス・モードをサポートするセグメントでサポートされます。
  
  関連項目:
  
  accessModes(), withAccessModes(int), 「定数フィールド値」
- WRITE
  
  static final int WRITE
  
  書込みアクセス・モード。書込み操作は、このアクセス・モードをサポートするセグメントでサポートされます。
  
  関連項目:
  
  accessModes(), withAccessModes(int), 「定数フィールド値」
- CLOSE
  
  static final int CLOSE
  
  アクセス・モードをクローズします。close()のコールは、このアクセス・モードをサポートするセグメントでサポートされます。
  
  関連項目:
  
  accessModes(), withAccessModes(int), 「定数フィールド値」
- SHARE
  
  static final int SHARE
  
  共有アクセス・モード。このセグメントは、所有者スレッド(share()を参照してください)以外のスレッドとの共有をサポートします。
  
  関連項目:
  
  accessModes(), withAccessModes(int), 「定数フィールド値」
- HANDOFF
  
  static final int HANDOFF
  
  ハンド・オフ・アクセス・モード。このセグメントは、スレッド所有権変更(handoff(NativeScope)およびhandoff(Thread)を参照)を介したシリアル・スレッド定義をサポートします。
  
  関連項目:
  
  accessModes(), withAccessModes(int), 「定数フィールド値」
- ALL_ACCESS
  
  static final int ALL_ACCESS
  
  デフォルトのアクセス・モード。これは、メモリー・セグメントでサポートされているすべてのアクセス・モードの和集合です。
  
  関連項目:
  
  accessModes(), withAccessModes(int), 「定数フィールド値」
メソッドの詳細
- address
  
  MemoryAddress address()
  
  このメモリー・セグメントに関連付けられているベース・メモリー・アドレス。返されるアドレスはcheckedメモリー・アドレスであるため、間接参照演算(MemoryAddressを参照してください)で使用できます。
  
  定義:
  
  インタフェースAddressable内のaddress
  
  戻り値:
  
  ベース・メモリー・アドレス。
  
  例外:
  
  IllegalStateException - このセグメントがaliveでない場合、またはこのセグメントを所有するスレッド以外のスレッドからアクセスが発生した場合
- spliterator
  
  Spliterator<MemorySegment> spliterator(SequenceLayout layout)
  
  このメモリー・セグメントのスプリッテレータを返します。返されるスプリッテレータは、Spliterator.SIZED、Spliterator.SUBSIZED、Spliterator.IMMUTABLE、Spliterator.NONNULLおよびSpliterator.ORDEREDの特性を報告します。
  返されたスプリッテレータは、指定されたシーケンス・レイアウトに従ってこのセグメントを分割します。つまり、指定されたレイアウトが要素数がNであるシーケンス・レイアウトである場合、Spliterator.trySplit()を呼び出すと、スプリッテレータがおよそのN/2要素(nが偶数かどうかによって異なります。)にサービスを提供します。そのため、N >= 2であれば分割が可能です。スプリッテレータは、指定されたセグメントからCLOSEアクセス・モードを引いたものと同じ「アクセス・モード」を特徴とするセグメントを返します。
  返されたスプリッテレータを使用すると、このセグメントを非結合サブ・セグメントに効果的にスライスして、複数のスレッド(セグメントが共有されている場合)で並行して処理できます。
  
  パラメータ:
  
  layout - 分割に使用されるレイアウト。
  
  戻り値:
  
  このセグメントの要素スプリッテレータ
  
  例外:
  
  IllegalStateException - セグメントがaliveでない場合、またはこのセグメントを所有するスレッド以外のスレッドからアクセスが発生した場合
- ownerThread
  
  Thread ownerThread()
  
  このセグメントを所有しているスレッド。
  
  戻り値:
  
  このセグメントを所有しているスレッド。
- byteSize
  
  long byteSize()
  
  このメモリー・セグメントのサイズは(バイト単位)です。
  
  戻り値:
  
  このメモリー・セグメントのサイズは(バイト単位)です。
- withAccessModes
  
  MemorySegment withAccessModes(int accessModes)
  
  特定の「アクセス・モード」を持つセグメント・ビューを取得します。サポートされているアクセス・モードは、READ、WRITE、CLOSE、SHAREおよびHANDOFFです。一般に、より厳密なアクセス・モードのセグメントからより厳密でないアクセス・モードのセグメントに移動することはできません。たとえば、読取り専用セグメントにWRITEアクセス・モードを追加しようとすると、例外が発生します。
  
  パラメータ:
  
  accessModes - ゼロ個以上のアクセス・モードのORedマスク。
  
  戻り値:
  
  特定のアクセス・モードを持つセグメント・ビュー。
  
  例外:
  
  IllegalArgumentException - maskがこのセグメントでサポートされているアクセス・マスクよりも厳密でない場合、またはサポートされているどのアクセス・モードにも関連付けられていないビットがmaskに含まれている場合。
- hasAccessModes
  
  boolean hasAccessModes(int accessModes)
  
  このセグメントは特定のアクセス・モードのセットをサポートしていますか。
  
  パラメータ:
  
  accessModes - ゼロ個以上のアクセス・モードのORedマスク。
  
  戻り値:
  
  accessModesのアクセス・モードがこのセグメントでサポートされているアクセス・モードより厳しい場合はtrue。
  
  例外:
  
  IllegalArgumentException - サポートされているどのアクセス・モードにも関連付けられていないビットがmaskに含まれている場合。
- accessModes
  
  int accessModes()
  
  このセグメントに関連付けられた「アクセス・モード」を返します。結果は、READ、WRITE、CLOSE、SHAREおよびHANDOFFからのORed値として表されます。
  
  戻り値:
  
  このセグメントに関連付けられたアクセス・モード。
- asSlice
  
  MemorySegment asSlice(long offset, long newSize)
  
  ベース・アドレスがこのセグメントのベース・アドレスと指定されたオフセットに加えて、指定の引数で新しいサイズが指定されている、新しいメモリー・セグメントのビューを取得します。
  
  パラメータ:
  
  offset - 新しいセグメント・ベース・オフセット(現在のセグメント・ベース・アドレスとの相対)(バイト単位)です。
  
  newSize - 新しいセグメント・サイズ(バイト単位で指定)。
  
  戻り値:
  
  ベース/制限アドレスが更新された新しいメモリー・セグメント・ビュー。
  
  例外:
  
  IndexOutOfBoundsException - offset < 0、offset > byteSize()、newSize < 0またはnewSize > byteSize() - offsetの場合
  
  関連項目:
  
  asSlice(long), asSlice(MemoryAddress), asSlice(MemoryAddress, long)
- asSlice
  
  default MemorySegment asSlice(MemoryAddress newBase, long newSize)
  ベース・アドレスが指定されたアドレスであり、新しいサイズが指定された引数で指定されている新しいメモリー・セグメント・ビューを取得します。
  次のコードと同等です:
  asSlice(newBase.segmentOffset(this), newSize);
  パラメータ:
  
  newBase - 新しいセグメント・ベース・アドレス。
  
  newSize - 新しいセグメント・サイズ(バイト単位で指定)。
  
  戻り値:
  
  ベース/制限アドレスが更新された新しいメモリー・セグメント・ビュー。
  
  例外:
  
  IndexOutOfBoundsException - offset < 0、offset > byteSize()、newSize < 0またはnewSize > byteSize() - offsetの場合
  
  関連項目:
  
  asSlice(long), asSlice(MemoryAddress), asSlice(long, long)
- asSlice
  
  default MemorySegment asSlice(long offset)
  ベース・アドレスがこのセグメントのベース・アドレスに指定されたオフセットを加えたものと同じであり、その新しいサイズがこのセグメント・サイズから指定されたオフセットを引いて計算される新しいメモリー・セグメント・ビューを取得します。
  次のコードと同等です:
  asSlice(offset, byteSize() - offset);
  パラメータ:
  
  offset - 新しいセグメント・ベース・オフセット(現在のセグメント・ベース・アドレスとの相対)(バイト単位)です。
  
  戻り値:
  
  ベース/制限アドレスが更新された新しいメモリー・セグメント・ビュー。
  
  例外:
  
  IndexOutOfBoundsException - if offset < 0,またはoffset > byteSize()。
  
  関連項目:
  
  asSlice(MemoryAddress), asSlice(MemoryAddress, long), asSlice(long, long)
- asSlice
  
  default MemorySegment asSlice(MemoryAddress newBase)
  ベース・アドレスが指定されたアドレスであり、このセグメント・サイズからこのセグメント(MemoryAddress.segmentOffset(MemorySegment)を参照してください)に相対的なアドレス・オフセットを減算して新しいサイズが計算される新しいメモリー・セグメント・ビューを取得します。
  次のコードと同等です:
  asSlice(newBase.segmentOffset(this));
  パラメータ:
  
  newBase - 新しいセグメント・ベース・オフセット(現在のセグメント・ベース・アドレスとの相対)(バイト単位)です。
  
  戻り値:
  
  ベース/制限アドレスが更新された新しいメモリー・セグメント・ビュー。
  
  例外:
  
  IndexOutOfBoundsException - if address.segmentOffset(this) < 0,またはaddress.segmentOffset(this) > byteSize()。
  
  関連項目:
  
  asSlice(long), asSlice(MemoryAddress, long), asSlice(long, long)
- isMapped
  
  boolean isMapped()
  
  これはマップ済セグメントですか? このセグメントが、mapFile(Path, long, long, FileChannel.MapMode)ファクトリを使用して作成されたマップ済みメモリー・セグメントである場合、またはofByteBuffer(ByteBuffer)ファクトリを使用してMappedByteBufferから派生したバッファ・セグメントである場合にtrueを返します。
  
  戻り値:
  
  このセグメントがマップされたセグメントである場合はtrue。
- isAlive
  
  boolean isAlive()
  
  このセグメントは動作していますか。
  
  戻り値:
  
  true:セグメントが有効な場合。
  
  関連項目:
  
  close()
- close
  
  void close()
  
  このメモリー・セグメントを閉じます。これは「終端演算」です。副作用として、この演算が例外なしで完了した場合、このセグメントは「生きていない」としてマークされ、このセグメントに対する後続の演算はIllegalStateExceptionで失敗します。
  クローズされるメモリー・セグメントの種類に応じて、このメソッドをコールすると、メモリー・セグメントに関連付けられているすべてのリソースの割当て解除がさらにトリガーされます。
  
  定義:
  
  close、インタフェース: AutoCloseable
  
  APIのノート:
  
  この演算は多重呼出し不変ではありません。つまり、すでにクローズされているセグメントalwaysをクローズすると、例外がスローされます。これは意図的な設計の選択を反映しています: セグメント状態遷移はクライアント・コードのマニフェストである必要があります。これらの遷移のいずれかが失敗すると、基礎となるアプリケーション・ロジックにバグが示されます。これは、依存セグメント・ビューのライフサイクルを推論する場合に特に便利です(あるセグメントを閉じると複数のセグメントに影響する可能性があるasSlice(MemoryAddress)を参照)。このような場合、実際には明白でない可能性があり、特定のセグメントが生存しているかどうかに関するコードを確認します。
  
  例外:
  
  IllegalStateException - このセグメントがaliveでない場合、またはこのセグメントを所有するスレッド以外のスレッドからアクセスが発生した場合、またはこのセグメントが共有され、このメソッドの呼出し中にセグメントが同時にアクセスされた場合。
  
  UnsupportedOperationException - このセグメントがCLOSEアクセス・モードをサポートしていない場合。
- handoff
  
  MemorySegment handoff(Thread thread)
  
  このセグメントと同じベースとなるメモリー・リージョンに連動する新しい制限されたメモリー・セグメントを取得します。返されるセグメントは、指定されたスレッドで制限され、このセグメントと同じ空間境界およびアクセス・モードの(accessModes()を参照してください)を特徴とします。
  これは「終端演算」です。副作用として、この演算が例外なしで完了した場合、このセグメントは「生きていない」としてマークされ、このセグメントに対する後続の演算はIllegalStateExceptionで失敗します。
  返されたセグメントの所有者スレッドがこのセグメントの所有者スレッドと異なる場合は、このセグメント・コンテンツへの書込みアクセス権が、現在の所有者スレッドから新しい所有者スレッドにhappens-beforeで引き継がれ、新しい所有者スレッドで返されたセグメント・コンテンツへの「以前に発生」読取りアクセス権が与えられます。
  
  パラメータ:
  
  thread - 新しい所有者スレッド
  
  戻り値:
  
  所有者スレッドがthreadに設定されている新しい制限付きメモリー・セグメント。
  
  例外:
  
  IllegalStateException - このセグメントがaliveでない場合、またはこのセグメントを所有するスレッド以外のスレッドからアクセスが発生した場合。
  
  UnsupportedOperationException - このセグメントがHANDOFFアクセス・モードをサポートしていない場合。
- handoff
  
  MemorySegment handoff(NativeScope nativeScope)
  
  このセグメントと同じベースとなるメモリー・リージョンに連動する、指定されたNativeScopeインスタンスによって一時的な境界が制御される新しい制限されたメモリー・セグメントを取得します。
  これは「終端演算」です。副作用として、このセグメントは「生きていない」としてマークされ、このセグメントに対する後続の演算はIllegalStateExceptionで失敗します。
  返されるセグメントには、READおよびWRITEアクセス・モードの(これらが元のセグメントで使用可能であると仮定した場合)のみが含まれます。そのため、戻されたセグメントは、close()を使用して直接クローズできません - ただし、このネイティブ・スコープがクローズされると間接的にクローズされます。返されるセグメントも、指定されたネイティブ・スコープ(NativeScope.ownerThread()を参照してください)と同じスレッドによって制限されます。
  返されたセグメントの所有者スレッドがこのセグメントの所有者スレッドと異なる場合は、このセグメント・コンテンツへの書込みアクセス権が、現在の所有者スレッドから新しい所有者スレッドにhappens-beforeで引き継がれ、新しい所有者スレッドで返されたセグメント・コンテンツへの「以前に発生」読取りアクセス権が与えられます。
  
  パラメータ:
  
  nativeScope - ネイティブ・スコープ。
  
  戻り値:
  
  このセグメントと同じベースとなるメモリー・リージョンに支えられているが、そのライフサイクルがnativeScopeのライフサイクルに関連付けられている新しいメモリー制限セグメント。
  
  例外:
  
  IllegalStateException - このセグメントがaliveでない場合、またはこのセグメントを所有するスレッド以外のスレッドからアクセスが発生した場合。
  
  UnsupportedOperationException - このセグメントがHANDOFFアクセス・モードをサポートしていない場合。
- share
  
  MemorySegment share()
  
  このセグメントと同じベースとなるメモリー・リージョンに連動する新しい共有メモリー・セグメントを取得します。返されるセグメントはどのスレッドでも制限されないため、複数のスレッドから同時にアクセスできます。また、返されるセグメントは、このセグメントと同じ空間境界およびアクセス・モード(accessModes()を参照してください)を備えています。
  これは「終端演算」です。副作用として、この演算が例外なしで完了した場合、このセグメントは「生きていない」としてマークされ、このセグメントに対する後続の演算はIllegalStateExceptionで失敗します。
  現在の所有者スレッドから新しい所有者スレッドへのhappens-beforeハンド・オーバーによるこのセグメント・コンテンツへの書込みアクセス権。これにより、「以前に発生」は新しいスレッドで返されたセグメント・コンテンツへの読取りアクセス権を持ちます。
  
  戻り値:
  
  このセグメントと同じベースとなるメモリー・リージョンに基づく新しいメモリー共有セグメント。
  
  例外:
  
  IllegalStateException - このセグメントがaliveでない場合、またはこのセグメントを所有するスレッド以外のスレッドからアクセスが発生した場合。
- registerCleaner
  
  MemorySegment registerCleaner(Cleaner cleaner)
  
  このメモリー・セグメント・インスタンスをCleanerオブジェクトに対して登録するには、このセグメントと同じ基礎となるメモリー・リージョンに連動する新しいメモリー・セグメントを戻します。戻されるセグメントには、このセグメントと同じ制限、空間境界およびアクセス・モードの(accessModes()を参照してください)が含まれます。さらに、戻されたセグメントは、指定されたCleanerオブジェクトに関連付けられます。これにより、セグメントがunreachableになるとすぐにクローズできるようになり、ネイティブ・メモリー・リークの防止に役立つ場合があります。
  これは「終端演算」です。副作用として、この演算が例外なしで完了した場合、このセグメントは「生きていない」としてマークされ、このセグメントに対する後続の演算はIllegalStateExceptionで失敗します。
  戻されたセグメントに関連付けられた暗黙的な割当て解除動作は、handoff(Thread)やshare()などのターミナル演算の下で保持されます。
  
  パラメータ:
  
  cleaner - 返されたセグメントの暗黙的な割当て解除を行うクリーナ・オブジェクト。
  
  戻り値:
  
  暗黙的な割当て解除を特徴とする、このセグメントと同じベースとなるメモリー・リージョンに基づく新しいメモリー・セグメント。
  
  例外:
  
  IllegalStateException - このセグメントがaliveでない場合、またはこのセグメントを所有するスレッド以外のスレッドからアクセスが発生した場合、またはこのセグメントがクリーナにすでに関連付けられている場合。
  
  UnsupportedOperationException - このセグメントがCLOSEアクセス・モードをサポートしていない場合。
- fill
  
  MemorySegment fill(byte value)
  このメモリー・セグメントに値を入力します。
  具体的には、指定された値がこのセグメントの各アドレスに入力されます。 (ただし、より効率的である可能性があります。)と同等のコードは次のとおりです:
  byteHandle = MemoryLayout.ofSequence(MemoryLayouts.JAVA_BYTE) .varHandle(byte.class, MemoryLayout.PathElement.sequenceElement()); for (long l = 0; l < segment.byteSize(); l++) { byteHandle.set(segment.address(), l, value); }
  設定される特定のメモリー要素の順序を考慮または保証しません。
  フィルは、セグメントのメモリーを初期化またはリセットする場合に便利です。
  パラメータ:
  
  value - このセグメントに入力する値
  
  戻り値:
  
  このメモリー・セグメント
  
  例外:
  
  IllegalStateException - このセグメントがaliveでない場合、またはこのセグメントを所有するスレッド以外のスレッドからアクセスが発生した場合
  
  UnsupportedOperationException - このセグメントがWRITEアクセス・モードをサポートしていない場合
- copyFrom
  
  void copyFrom(MemorySegment src)
  
  指定されたソース・セグメントからこのセグメントへの一括コピーを実行します。具体的には、ソース・セグメントのオフセット0からsrc.byteSize() - 1までのバイトは、src.byteSize() - 1を介したオフセット0でこのセグメントにコピーされます。ソース・セグメントがこのセグメントと重複する場合、コピーは、ソース・セグメント内のsrc.byteSize() - 1を介してオフセット0のバイトが最初にサイズがbytesの一時セグメントにコピーされたかのように実行され、一時セグメントの内容がsrc.byteSize() - 1を介してオフセット0でこのセグメントにコピーされます。
  ソース・セグメントとこのセグメントが重複せず、異なるアドレスを使用して同じバッキング・ストレージの重複するリージョンを参照している場合、一括コピーの結果は不確定です。たとえば、同じファイルが複数のセグメントに対してmappedである場合に発生することがあります。
  
  パラメータ:
  
  src - ソース・セグメント。
  
  例外:
  
  IndexOutOfBoundsException - src.byteSize() > this.byteSize()の場合。
  
  IllegalStateException - ソース・セグメントまたはこのセグメントがすでにクローズされている場合、またはいずれかのセグメントを所有しているスレッド以外のスレッドからアクセスが発生した場合。
  
  UnsupportedOperationException - ソース・セグメントまたはこのセグメントのいずれかが必要なアクセス・モードを機能していない場合。具体的には、srcは少なくともREADアクセス・モードを機能させ、このセグメントは少なくともWRITEアクセス・モードを機能させる必要があります。
- mismatch
  
  long mismatch(MemorySegment other)
  
  このセグメントと指定された他のセグメント間の最初の不一致のオフセットをバイト単位で検索して返します。オフセットは各セグメントのbase addressに対して相対的で、小さいメモリー・セグメント(exclusive)のsize (バイト単位)までの0 (inclusive)の範囲になります。
  2つのセグメントが共通のプレフィクスを共有している場合、返されるオフセットは共通のプレフィクスの長さであり、各セグメント内のそのオフセットにある2つのセグメント間に不一致があることに従います。一方のセグメントが他方のセグメントの適切なプレフィクスである場合、返されるオフセットはセグメント・サイズの小さい方になり、オフセットは大きいセグメントに対してのみ有効であることに従います。それ以外の場合、不一致はなく、 -1が返されます。
  
  パラメータ:
  
  other - このセグメントとの不一致をテストするセグメント
  
  戻り値:
  
  このセグメントと指定された他のセグメント間の最初の不一致の相対オフセット(バイト)。不一致がない場合は -1
  
  例外:
  
  IllegalStateException - 他のセグメントのこのセグメントがすでにクローズされている場合、またはいずれかのセグメントを所有しているスレッド以外のスレッドからアクセスが発生した場合
  
  UnsupportedOperationException - このセグメントまたは他のセグメントが少なくともREADアクセス・モードを機能していない場合
- asByteBuffer
  
  ByteBuffer asByteBuffer()
  
  ByteBufferでこのセグメントをラップします。返されたバッファのプロパティの一部は、このセグメントのプロパティにリンクされています。たとえば、このセグメントが「不変」 (たとえば、セグメントにはアクセス・モードREADがありますが、WRITEはありません。)の場合、結果のバッファはread-onlyになります(Buffer.isReadOnly()を参照)。また、これがネイティブ・メモリー・セグメントの場合は、結果のバッファはdirect (ByteBuffer.isDirect()を参照してください)になります。
  戻されるバッファ位置(Buffer.position()を参照)。一方、戻されるバッファ容量および制限の(Buffer.capacity()およびBuffer.limit()をそれぞれ参照)は、このセグメントのサイズ(byteSize()を参照してください)に設定されます。このため、このセグメントのサイズがInteger.MAX_VALUEより大きい場合、byteバッファは返されません。
  返されるバッファのライフサイクルは、このセグメントのライフサイクルと関連します。これは、このセグメントが閉じられている場合(close()を参照)、返されたバッファにアクセスするとIllegalStateExceptionがスローされることを意味します。
  このセグメントがsharedの場合、結果のバッファで特定のI/O演算を呼び出すと、未指定の例外がスローされる可能性があります。このような問題のある演算には、FileChannel.read(ByteBuffer)、FileChannel.write(ByteBuffer)、SocketChannel.read(ByteBuffer)、SocketChannel.write(ByteBuffer)などがあります。
  最後に、結果のバッファ・バイト順序はByteOrder.BIG_ENDIANです。これは、ByteBuffer.order(java.nio.ByteOrder)を使用して変更できます。
  
  戻り値:
  
  このメモリー・セグメントのByteBufferビュー。
  
  例外:
  
  UnsupportedOperationException - このセグメントをByteBufferインスタンスにマップできない場合(たとえば、byte[]に基づかないヒープ・ベースのセグメントをモデル化する場合)、そのサイズがInteger.MAX_VALUEより大きい場合、またはセグメントがREADアクセス・モードをサポートしていない場合。
- toByteArray
  
  byte[] toByteArray()
  
  このメモリー・セグメントの内容を新しいバイト配列にコピーします。
  
  戻り値:
  
  このメモリー・セグメントの新しいバイト配列のコピー。
  
  例外:
  
  UnsupportedOperationException - このセグメントがREADアクセス・モードを機能していない場合、またはこのセグメントの内容をbyteインスタンスにコピーできない場合(たとえば、サイズがInteger.MAX_VALUEより大きい場合)、
  
  IllegalStateException - このセグメントがクローズされている場合、またはこのセグメントを所有しているスレッド以外のスレッドからアクセスが発生した場合。
- toShortArray
  
  short[] toShortArray()
  
  このメモリー・セグメントの内容を新しいshort配列にコピーします。
  
  戻り値:
  
  このメモリー・セグメントの新しいshort配列コピー。
  
  例外:
  
  UnsupportedOperationException - このセグメントにREADアクセス・モードが設定されていない場合、またはこのセグメントの内容をbyteSize() % 2 != 0やbyteSize() / 2 > Integer#MAX_VALUEなどのshortインスタンスにコピーできない場合。
  
  IllegalStateException - このセグメントがクローズされている場合、またはこのセグメントを所有しているスレッド以外のスレッドからアクセスが発生した場合。
- toCharArray
  
  char[] toCharArray()
  
  このメモリー・セグメントの内容を新しいchar配列にコピーします。
  
  戻り値:
  
  このメモリー・セグメントの新しいchar配列コピー。
  
  例外:
  
  UnsupportedOperationException - このセグメントにREADアクセス・モードが設定されていない場合、またはこのセグメントの内容をbyteSize() % 2 != 0やbyteSize() / 2 > Integer#MAX_VALUEなどのcharインスタンスにコピーできない場合。
  
  IllegalStateException - このセグメントがクローズされている場合、またはこのセグメントを所有しているスレッド以外のスレッドからアクセスが発生した場合。
- toIntArray
  
  int[] toIntArray()
  
  このメモリー・セグメントの内容を新しいint配列にコピーします。
  
  戻り値:
  
  このメモリー・セグメントの新しいint配列コピー。
  
  例外:
  
  UnsupportedOperationException - このセグメントにREADアクセス・モードが設定されていない場合、またはこのセグメントの内容をbyteSize() % 4 != 0やbyteSize() / 4 > Integer#MAX_VALUEなどのintインスタンスにコピーできない場合。
  
  IllegalStateException - このセグメントがクローズされている場合、またはこのセグメントを所有しているスレッド以外のスレッドからアクセスが発生した場合。
- toFloatArray
  
  float[] toFloatArray()
  
  このメモリー・セグメントの内容を新しいfloat配列にコピーします。
  
  戻り値:
  
  このメモリー・セグメントの新しいfloat配列コピー。
  
  例外:
  
  UnsupportedOperationException - このセグメントにREADアクセス・モードが設定されていない場合、またはこのセグメントの内容をbyteSize() % 4 != 0やbyteSize() / 4 > Integer#MAX_VALUEなどのfloatインスタンスにコピーできない場合。
  
  IllegalStateException - このセグメントがクローズされている場合、またはこのセグメントを所有しているスレッド以外のスレッドからアクセスが発生した場合。
- toLongArray
  
  long[] toLongArray()
  
  このメモリー・セグメントの内容を新しいlong配列にコピーします。
  
  戻り値:
  
  このメモリー・セグメントの新しいlong配列コピー。
  
  例外:
  
  UnsupportedOperationException - このセグメントにREADアクセス・モードが設定されていない場合、またはこのセグメントの内容をbyteSize() % 8 != 0やbyteSize() / 8 > Integer#MAX_VALUEなどのlongインスタンスにコピーできない場合。
  
  IllegalStateException - このセグメントがクローズされている場合、またはこのセグメントを所有しているスレッド以外のスレッドからアクセスが発生した場合。
- toDoubleArray
  
  double[] toDoubleArray()
  
  このメモリー・セグメントの内容を新しいdouble配列にコピーします。
  
  戻り値:
  
  このメモリー・セグメントの新しいdouble配列コピー。
  
  例外:
  
  UnsupportedOperationException - このセグメントにREADアクセス・モードが設定されていない場合、またはこのセグメントの内容をbyteSize() % 8 != 0やbyteSize() / 8 > Integer#MAX_VALUEなどのdoubleインスタンスにコピーできない場合。
  
  IllegalStateException - このセグメントがクローズされている場合、またはこのセグメントを所有しているスレッド以外のスレッドからアクセスが発生した場合。
- ofByteBuffer
  
  static MemorySegment ofByteBuffer(ByteBuffer bb)
  
  指定されたbyteバッファに関連付けられたメモリーをモデル化する、新しい制限付きバッファ・メモリー・セグメントを作成します。セグメントはバッファ位置(inclusive)から相対的に始まり、バッファ制限(exclusive)に対して相対的に終わります。
  セグメントは、指定されたバッファがread-onlyでないかぎり、すべての「アクセス・モード」 (ALL_ACCESSを参照してください)を特徴とします。read-onlyの場合、セグメントはWRITEアクセス・モードを特徴とせず、その制限スレッドは現在のスレッド(Thread.currentThread()を参照してください)です。
  結果のメモリー・セグメントは、バッキングバッファへの参照を保持しているため、セグメントの有効期間「到達可能」のままです。
  
  パラメータ:
  
  bb - バッファ・メモリー・セグメントをバッキングするバイト・バッファ。
  
  戻り値:
  
  新しい制限付きバッファ・メモリー・セグメント。
- ofArray
  
  static MemorySegment ofArray(byte[] arr)
  
  指定されたヒープ割当てのバイト配列に関連付けられたメモリーをモデル化する新しい制限付き配列メモリー・セグメントを作成します。
  結果のメモリー・セグメントは、バッキング配列への参照を保持し、セグメントの有効期間中「到達可能」を保持します。セグメントはすべての「アクセス・モード」 (ALL_ACCESSを参照してください)を特徴とし、その制限スレッドは現在のスレッド(Thread.currentThread()を参照してください)です。
  
  パラメータ:
  
  arr - 配列メモリー・セグメントにバックアップするプリミティブ配列。
  
  戻り値:
  
  新しい制限付き配列メモリー・セグメント。
- ofArray
  
  static MemorySegment ofArray(char[] arr)
  
  指定されたヒープ割当てのchar配列に関連付けられたメモリーをモデル化する新しい制限付き配列メモリー・セグメントを作成します。
  結果のメモリー・セグメントは、バッキング配列への参照を保持し、セグメントの有効期間中「到達可能」を保持します。セグメントはすべての「アクセス・モード」 (ALL_ACCESSを参照してください)を特徴とし、その制限スレッドは現在のスレッド(Thread.currentThread()を参照してください)です。
  
  パラメータ:
  
  arr - 配列メモリー・セグメントにバックアップするプリミティブ配列。
  
  戻り値:
  
  新しい制限付き配列メモリー・セグメント。
- ofArray
  
  static MemorySegment ofArray(short[] arr)
  
  指定されたヒープ割当てのshort配列に関連付けられたメモリーをモデル化する新しい制限付き配列メモリー・セグメントを作成します。
  結果のメモリー・セグメントは、バッキング配列への参照を保持し、セグメントの有効期間中「到達可能」を保持します。セグメントはすべての「アクセス・モード」 (ALL_ACCESSを参照してください)を特徴とし、その制限スレッドは現在のスレッド(Thread.currentThread()を参照してください)です。
  
  パラメータ:
  
  arr - 配列メモリー・セグメントにバックアップするプリミティブ配列。
  
  戻り値:
  
  新しい制限付き配列メモリー・セグメント。
- ofArray
  
  static MemorySegment ofArray(int[] arr)
  
  指定されたヒープ割当てのint配列に関連付けられたメモリーをモデル化する新しい制限付き配列メモリー・セグメントを作成します。
  結果のメモリー・セグメントは、バッキング配列への参照を保持し、セグメントの有効期間中「到達可能」を保持します。セグメントはすべての「アクセス・モード」 (ALL_ACCESSを参照してください)を特徴とし、その制限スレッドは現在のスレッド(Thread.currentThread()を参照してください)です。
  
  パラメータ:
  
  arr - 配列メモリー・セグメントにバックアップするプリミティブ配列。
  
  戻り値:
  
  新しい制限付き配列メモリー・セグメント。
- ofArray
  
  static MemorySegment ofArray(float[] arr)
  
  指定されたヒープ割当てのfloat配列に関連付けられたメモリーをモデル化する新しい制限付き配列メモリー・セグメントを作成します。
  結果のメモリー・セグメントは、バッキング配列への参照を保持し、セグメントの有効期間中「到達可能」を保持します。セグメントはすべての「アクセス・モード」 (ALL_ACCESSを参照してください)を特徴とし、その制限スレッドは現在のスレッド(Thread.currentThread()を参照してください)です。
  
  パラメータ:
  
  arr - 配列メモリー・セグメントにバックアップするプリミティブ配列。
  
  戻り値:
  
  新しい制限付き配列メモリー・セグメント。
- ofArray
  
  static MemorySegment ofArray(long[] arr)
  
  指定されたヒープ割当てのlong配列に関連付けられたメモリーをモデル化する新しい制限付き配列メモリー・セグメントを作成します。
  結果のメモリー・セグメントは、バッキング配列への参照を保持し、セグメントの有効期間中「到達可能」を保持します。セグメントはすべての「アクセス・モード」 (ALL_ACCESSを参照してください)を特徴とし、その制限スレッドは現在のスレッド(Thread.currentThread()を参照してください)です。
  
  パラメータ:
  
  arr - 配列メモリー・セグメントにバックアップするプリミティブ配列。
  
  戻り値:
  
  新しい制限付き配列メモリー・セグメント。
- ofArray
  
  static MemorySegment ofArray(double[] arr)
  
  指定されたヒープ割当てのdouble配列に関連付けられたメモリーをモデル化する新しい制限付き配列メモリー・セグメントを作成します。
  結果のメモリー・セグメントは、バッキング配列への参照を保持し、セグメントの有効期間中「到達可能」を保持します。セグメントは、すべての「アクセス・モード」 (ALL_ACCESSを参照してください)を特徴とします。
  
  パラメータ:
  
  arr - 配列メモリー・セグメントにバックアップするプリミティブ配列。
  
  戻り値:
  
  新しい制限付き配列メモリー・セグメント。
- allocateNative
  
  static MemorySegment allocateNative(MemoryLayout layout)
  指定されたレイアウトで新しく割り当てられたオフ・ヒープ・メモリーのブロックをモデル化する、新しい制限されたネイティブ・メモリー・セグメントを作成します。
  これは次のコードと等価です。
  allocateNative(layout.bytesSize(), layout.bytesAlignment());
  実装上のノート:
  
  返されたネイティブ・メモリー・セグメントに関連するoff-heapメモリーのブロックは、ゼロに初期化されます。さらに、クライアントはネイティブ・メモリー・セグメントでclose()をコールし、それに応じてバッキング・オフ・ヒープ・マージ・ブロックが割当て解除されるようにします。これを行わなかった場合、ヒープ外のメモリー・リークが発生します。
  
  パラメータ:
  
  layout - ネイティブ・メモリー・セグメントのバッキングの非ヒープ・メモリー・ブロックのレイアウト。
  
  戻り値:
  
  新しいネイティブ・メモリー・セグメント。
  
  例外:
  
  IllegalArgumentException - 指定されたレイアウトに不正なサイズ制約または位置合せ制約がある場合。
- allocateNative
  
  static MemorySegment allocateNative(long bytesSize)
  指定されたサイズ(バイト単位)のオフ・ヒープ・メモリーの新しく割り当てられたブロックをモデル化する、新しい制限付きネイティブ・メモリー・セグメントを作成します。
  これは次のコードと等価です。
  allocateNative(bytesSize, 1);
  実装上のノート:
  
  返されたネイティブ・メモリー・セグメントに関連するoff-heapメモリーのブロックは、ゼロに初期化されます。さらに、クライアントはネイティブ・メモリー・セグメントでclose()をコールし、それに応じてバッキング・オフ・ヒープ・マージ・ブロックが割当て解除されるようにします。これを行わなかった場合、ヒープ外のメモリー・リークが発生します。
  
  パラメータ:
  
  bytesSize - ネイティブ・メモリー・セグメントのバッキングのヒープ外メモリー・ブロックのサイズ(バイト単位)。
  
  戻り値:
  
  新しい制限付きネイティブ・メモリー・セグメント。
  
  例外:
  
  IllegalArgumentException - bytesSize < 0の場合。
- mapFile
  
  static MemorySegment mapFile(Path path, long bytesOffset, long bytesSize, FileChannel.MapMode mapMode) throws IOException
  
  指定されたパスからファイルのメモリー・マップ・リージョンをモデル化する、新しい制限付きマップ・メモリー・セグメントを作成します。
  セグメントは、指定されたマッピング・モードがREAD_ONLYでないかぎり、すべての「アクセス・モード」 (ALL_ACCESSを参照してください)を特徴とします。この場合、セグメントはWRITEアクセス・モードを特徴とせず、その制限スレッドは現在のスレッド(Thread.currentThread()を参照してください)です。
  マップされたメモリー・セグメントの内容は、マップされたファイルの対応するリージョンの内容がこの(または別の)プログラムによって変更される場合など、いつでも変更できます。こうした変更が発生するかどうか、またどのタイミングで発生するかは、オペレーティング・システムによって異なるため、未指定です。
  マップされたメモリー・セグメントのすべてまたは一部は、バッキング・マップ・ファイルが切り捨てられた場合など、いつでもアクセスできなくなる可能性があります。マップされたメモリー・セグメントのアクセス不可能なリージョンにアクセスしようとしても、セグメントの内容は変更されず、アクセス時または後で未指定の例外がスローされます。したがって、ファイルの内容の読取りまたは書込みを除き、この(または別の)プログラムによるマップ済ファイルの操作を回避するために、適切な注意を払うことを強くお薦めします。
  
  実装上のノート:
  
  新たに作成されたファイルからマップされたセグメントを取得する場合、返されたマップ済メモリー・セグメントに関連付けられているマップ済メモリー・ブロックのコンテンツの初期化状態は未指定であり、判断すべきではありません。
  
  パラメータ:
  
  path - メモリー・マップへのファイルのパス。
  
  bytesOffset - マップされたセグメントを開始するファイル内のオフセット(バイトで表されます。)。
  
  bytesSize - メモリー・セグメントをバッキングするマップ済メモリーのサイズ(バイト単位)。
  
  mapMode - ファイル・マッピング・モード。FileChannel.map(FileChannel.MapMode, long, long)を参照してください。選択したマッピング・モードは、返されるメモリー・マップ・セグメント(MappedMemorySegments.force(MemorySegment)を参照してください)の動作に影響する可能性があります。
  
  戻り値:
  
  新しい制限されたマップ済メモリー・セグメント。
  
  例外:
  
  IllegalArgumentException - bytesOffset < 0、bytesSize < 0またはpathがデフォルトのファイル・システムに関連付けられていない場合。
  
  UnsupportedOperationException - サポートされていないマップ・モードが指定された場合。
  
  IOException - 指定したパスが既存のファイルを指し示していないか、他のI/Oエラーが発生した場合。
  
  SecurityException - セキュリティ・マネージャがインストールされ、それが実装によって必要とされる未指定のアクセス権を拒否する場合。デフォルト・プロバイダで、ファイルが読取り用に開かれた場合は、SecurityManager.checkRead(String)メソッドが呼び出されてファイルへの読取りアクセスがチェックされます。ファイルが書込み用に開かれた場合は、SecurityManager.checkWrite(String)メソッドが呼び出されて書込みアクセスがチェックされます。
- allocateNative
  
  static MemorySegment allocateNative(long bytesSize, long alignmentBytes)
  
  指定されたサイズおよび配置の制約(バイト単位)を使用して、新しく割り当てられたオフ・ヒープ・メモリーのブロックをモデル化する新しい制限付きネイティブ・メモリー・セグメントを作成します。セグメントはすべての「アクセス・モード」 (ALL_ACCESSを参照してください)を特徴とし、その制限スレッドは現在のスレッド(Thread.currentThread()を参照してください)です。
  
  実装上のノート:
  
  返されたネイティブ・メモリー・セグメントに関連するoff-heapメモリーのブロックは、ゼロに初期化されます。さらに、クライアントはネイティブ・メモリー・セグメントでclose()をコールし、それに応じてバッキング・オフ・ヒープ・マージ・ブロックが割当て解除されるようにします。これを行わなかった場合、ヒープ外のメモリー・リークが発生します。
  
  パラメータ:
  
  bytesSize - ネイティブ・メモリー・セグメントのバッキングのヒープ外メモリー・ブロックのサイズ(バイト単位)。
  
  alignmentBytes - ネイティブ・メモリー・セグメントのバッキングのヒープ外メモリー・ブロックの位置合せ制約(バイト単位)。
  
  戻り値:
  
  新しい制限付きネイティブ・メモリー・セグメント。
  
  例外:
  
  IllegalArgumentException - bytesSize < 0、alignmentBytes < 0またはalignmentBytesが2の累乗でない場合。
- ofNativeRestricted
  
  static MemorySegment ofNativeRestricted()
  ベース・アドレスがMemoryAddress.NULLで、サイズがLong.MAX_VALUEである共有ネイティブ・メモリー・セグメントを返します。このメソッドは、ネイティブ・ライブラリと対話するときに取得したメモリー・アドレスを間接参照する場合に非常に便利です。このセグメントには、READおよびWRITE 「アクセス・モード」が含まれます。 (ただし、より効率的である可能性があります。)と同等のコードは次のとおりです:
  MemoryAddress.NULL.asSegmentRestricted(Long.MAX_VALUE) .withOwnerThread(null) .withAccessModes(READ | WRITE);
  
  このメソッドは「制限付き」です。制限されたメソッドは安全ではなく、誤って使用するとJVMがクラッシュしたり、悪化したりするとメモリーが破損する可能性があります。したがって、クライアントは制限付きメソッドに応じて屈折し、可能な場合は安全でサポートされている機能を使用する必要があります。
  戻り値:
  
  ベース・アドレスがMemoryAddress.NULLで、サイズがLong.MAX_VALUEであるメモリー・セグメント。
  
  例外:
  
  IllegalAccessError - ランタイム・プロパティforeign.restrictedがpermit、warnまたはdebug (デフォルト値はdenyに設定されています)のいずれにも設定されていない場合。

インタフェースMemorySegment

メモリー・セグメントの構築

明示的な割当て解除

アクセス・モード

メモリー・セグメント・ビュー

スレッド制限

暗黙的な割当て解除

フィールドのサマリー

メソッドのサマリー

フィールド詳細

READ

WRITE

CLOSE

SHARE

HANDOFF

ALL_ACCESS

メソッドの詳細

address

spliterator

ownerThread

byteSize

withAccessModes

hasAccessModes

accessModes

asSlice

asSlice

asSlice

asSlice

isMapped

isAlive

close

handoff

handoff

share

registerCleaner

fill

copyFrom

mismatch

asByteBuffer

toByteArray

toShortArray

toCharArray

toIntArray

toFloatArray

toLongArray

toDoubleArray

ofByteBuffer

ofArray

ofArray

ofArray

ofArray

ofArray

ofArray

ofArray

allocateNative

allocateNative

mapFile

allocateNative

ofNativeRestricted