Java Academy · Lektion

MemorySegment und Arena

Off-Heap-Speicher reservieren

MemorySegment und Arena ist eine kostenlose Java Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Java Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.

Off-Heap-Speicher

FFM bildet nativen Off-Heap-Speicher mit zwei zentralen Typen ab: MemorySegment steht für einen zusammenhängenden Speicherbereich, und Arena steuert dessen Lebensdauer.

Gemeinsam ersetzen sie die unsichere manuelle Pufferverwaltung der Vergangenheit.

Was ist ein MemorySegment

Ein MemorySegment ist ein typisiertes Fenster über einem Speicherblock. Es kennt seine Größe und seine Lebensdauer, und jeder Zugriff wird auf die Grenzen geprüft.

Segmente können außerhalb des Heaps (nativ) liegen oder ein On-Heap-Array umschließen.

Was ist eine Arena

Eine Arena reserviert Segmente und legt fest, wann diese freigegeben werden. Beim Schließen der Arena werden alle zugehörigen Segmente in einem deterministischen Schritt ungültig.

Arena.ofConfined(): ein Thread, explizites Schließen
Arena.ofShared(): Zugriff durch mehrere Threads
Arena.global(): wird nie freigegeben
Arena.ofAuto(): wird vom GC freigegeben

Ein Segment reservieren

Eine Arena mit Thread-Bindung in try-with-resources ist das typische Muster. Reservieren Sie Bytes, verwenden Sie sie, und beim Schließen wird alles freigegeben.

import java.lang.foreign.*;

public class Main {
    public static void main(String[] args) {
        try (Arena arena = Arena.ofConfined()) {
            MemorySegment seg = arena.allocate(16);
            System.out.println("Allocated bytes: " + seg.byteSize());
        }
        System.out.println("Arena closed, memory freed");
    }
}

Schreiben und Lesen

Sie lesen und schreiben über typisierte Zugriffsmethoden, die ein ValueLayout und einen Offset entgegennehmen. Dadurch bleiben Zugriffe typsicher und korrekt ausgerichtet.

import java.lang.foreign.*;

public class Main {
    public static void main(String[] args) {
        try (Arena arena = Arena.ofConfined()) {
            MemorySegment seg = arena.allocate(ValueLayout.JAVA_INT);
            seg.set(ValueLayout.JAVA_INT, 0, 42);
            int value = seg.get(ValueLayout.JAVA_INT, 0);
            System.out.println("Stored and read: " + value);
        }
    }
}

Typisierte Speicherplätze reservieren

Statt rohe Byte-Anzahlen zu verwenden, reservieren Sie anhand eines Layouts. arena.allocate(JAVA_INT) reserviert genau genügend, korrekt ausgerichtete Bytes für ein int.

Dadurch entfällt die manuelle Größenberechnung.

Wertearrays

Um mehrere Elemente zu speichern, reservieren Sie ein SequenceLayout oder übergeben eine Anzahl. Beim Indexzugriff wird der Offset anhand der Elementgröße berechnet.

import java.lang.foreign.*;

public class Main {
    public static void main(String[] args) {
        try (Arena arena = Arena.ofConfined()) {
            MemorySegment ints = arena.allocate(ValueLayout.JAVA_INT, 5);
            for (int i = 0; i < 5; i++) {
                ints.setAtIndex(ValueLayout.JAVA_INT, i, i * 10);
            }
            System.out.println("Element 3: " + ints.getAtIndex(ValueLayout.JAVA_INT, 3));
        }
    }
}

Grenzprüfung

Das Lesen oder Schreiben außerhalb eines Segments löst IndexOutOfBoundsException aus. Der Zugriff auf ein Segment nach dem Schließen seiner Arena löst IllegalStateException aus.

Diese Prüfungen machen den Speicher von FFM sicher, anders als bei JNI.

Thread-Bindung

Eine Confined-Arena bindet ihre Segmente an den Thread, der sie erstellt hat. Greift ein anderer Thread darauf zu, wird WrongThreadException ausgelöst.

Für tatsächlich gemeinsam genutzten Speicher verwenden Sie Arena.ofShared(). Diese Variante erlaubt den Zugriff durch mehrere Threads und verursacht nur einen geringen Mehraufwand.

Arbeiten mit Strings

FFM bietet Hilfsmethoden, um Java-Strings und C-Strings zu verbinden. allocateUtf8String (neuer: allocateFrom) schreibt einen nullterminierten String, und getUtf8String liest einen solchen wieder ein.

import java.lang.foreign.*;

public class Main {
    public static void main(String[] args) {
        try (Arena arena = Arena.ofConfined()) {
            MemorySegment cString = arena.allocateUtf8String("hello");
            System.out.println("Read back: " + cString.getUtf8String(0));
        }
    }
}

Eine Arena auswählen

Richtlinien:

Kurzlebige Puffer für einen einzelnen Thread: ofConfined()
Gemeinsame Nutzung durch mehrere Threads: ofShared()
Lebensdauer durch den GC verwaltet: ofAuto()
Prozessweite Konstanten: global()

Kurzer Test

Rufen Sie sich ins Gedächtnis, wodurch bestimmt wird, wann nativer Speicher freigegeben wird.

Zusammenfassung

Sie haben die Verwaltung von Off-Heap-Speicher kennengelernt:

MemorySegment: ein Speicherbereich mit Grenzprüfung
Arena: steuert die Lebensdauer (threadgebunden, gemeinsam genutzt, automatisch oder global)
Typisierter Zugriff über ValueLayout mit get/set und getAtIndex
Sicherheit durch Grenzprüfungen und Thread-Bindung

Als Nächstes: native Funktionen mit Downcall-Handles aufrufen.

Häufig gestellte Fragen

Ist die Lektion „MemorySegment und Arena“ kostenlos?

Ja — der vollständige Text von „MemorySegment und Arena“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Java Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „MemorySegment und Arena“?

Off-Heap-Speicher reservieren Du übst Java Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Java Academy zu starten?

Keine Vorkenntnisse erforderlich. Java Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.

Wie lange dauert die Lektion „MemorySegment und Arena“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Java Academy-Lektion Code schreiben und ausführen?

Ja. Jede Java Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Java Academy