What is the Foreign Function & Memory API in Java, and why was it added?

## The problem this API solves A running Java program normally only touches the **Java heap** — memory managed by the JVM and cleaned up automatically by the **garbage collector (GC)**. But sometimes Java needs to step outside this comfortable world: 1. **Off-heap memory** — large buffers, memory-mapped files, or data shared with hardware/native code, which you want to manage manually rather than letting the GC move or own it. 2. **Native functions** — calling code written in C/C++ (e.g. an OS API, or a fast math/crypto/ML library) that has no Java equivalent. Before this API, both were painful: - **JNI (Java Native Interface)** was the official way to call native code, but it required you to write a layer of **C glue code**, compile it for every platform, and follow fragile conventions. Mistakes caused JVM crashes, and crossing the boundary was slow. - **`sun.misc.Unsafe`** and **direct `ByteBuffer`** were used for off-heap memory. `Unsafe` is an *internal* JDK class never meant for public use — using it could corrupt memory and crash the JVM, and the JDK team wants to remove it. Direct `ByteBuffer` is limited (max ~2GB, no deterministic free). ## What the FFM API is The **Foreign Function & Memory API (FFM)** lives in the package **`java.lang.foreign`**. It was developed under **Project Panama**, went through several preview rounds, and was **finalized (made a permanent, stable feature) in Java 22** (2024). "Foreign" means "outside the Java world" — foreign *memory* (off-heap) and foreign *functions* (native code). Its two halves: - **Foreign Memory** — allocate, read, write, and free memory outside the heap, *safely*. - **Foreign Function** — locate and call C functions from pure Java, and even let C call back into Java. ## Key terms (defined) - **MemorySegment**: an object representing a contiguous, *bounded* region of memory (on- or off-heap). "Bounded" means it knows its own size, so reads/writes past the end throw a Java exception instead of corrupting random memory. - **Arena**: an object that owns the *lifetime* of one or more segments. Allocating from an arena gives you memory; closing the arena frees all of it at a single, deterministic moment. This is what makes off-heap memory safe and leak-resistant. - **Linker**: the bridge to native code. `Linker.nativeLinker()` can produce a **MethodHandle** (a callable function reference) bound to a C function, so you invoke C as if it were a Java method. ## Why it matters / design goals The three explicit goals are **safety** (misuse throws exceptions, not segfaults), **performance** (competitive with JNI and `Unsafe`), and **a pure-Java experience** (no separate C compiler step for the common cases). It is positioned as the modern replacement that lets the JDK eventually remove `Unsafe` and reduce reliance on JNI. ## A taste of the code ```java import java.lang.foreign.*; import java.lang.invoke.MethodHandle; try (Arena arena = Arena.ofConfined()) { // Off-heap memory: a C string "hi" MemorySegment str = arena.allocateUtf8String("hi"); // Foreign function: call C's strlen Linker linker = Linker.nativeLinker(); MethodHandle strlen = linker.downcallHandle( linker.defaultLookup().find("strlen").orElseThrow(), FunctionDescriptor.of(ValueLayout.JAVA_LONG, ValueLayout.ADDRESS)); long len = (long) strlen.invoke(str); // -> 2 } // arena closes here: the off-heap memory is freed deterministically ``` This single snippet shows both halves: off-heap allocation via an `Arena`, and a native call via the `Linker` — all in Java, no handwritten C.