Java 21 introduced the Foreign Function & Memory API to solve the complexity, poor security, and large performance overhead of JNI; 2. The core components include MemorySegment (memory abstraction), ValueLayout/MemoryLayout (memory layout), SymbolLookup (function symbol lookup), FunctionDescriptor and MethodHandle (function call definition), Arena (memory lifecycle management); 3. Pure Java code can call local functions and operate off-heap memory safely and efficiently, without writing C code or manually managing memory; 4. Compared with JNI, FFM API provides stronger type safety, automatic memory management, better performance and higher security; 5. Currently in Java The preview feature in 21 requires the enable-preview. It is not recommended for use in production environments and is expected to be officially released in subsequent versions.

Java 21 introduces the Foreign Function & Memory API (FFM API), an important new feature designed to enable Java programs to safely and efficiently call local libraries (such as dynamic link libraries written in C/C) and interact with off-heap memory. It replaces the long-standing but problematic JNI (Java Native Interface), providing a more modern, concise and safer way to handle interoperability with native code.

The core goal of this API is to enable Java to access local functions and memory naturally like calling local methods, while avoiding the complexity and security risks of JNI.

1. Why do you need the Foreign Function & Memory API?

Prior to Java 21, interacting with native code mainly relies on JNI , but it has many problems:

• Complex and complicated : it requires writing C code, generating header files, compiling shared libraries, and the development process is not smooth.
• Error-prone : Manually managing memory and type conversions can easily lead to crashes (such as segfaults).
• Performance overhead : JNI calls have high context switching costs.
• Poor security : direct operation of pointers, lack of memory access bounds checking.

The emergence of the Foreign Function & Memory API is to solve these problems and provides a pure Java way to implement external function calls and memory operations.

2. Detailed explanation of core components

The FFM API is mainly composed of the following key classes, located in java.lang.foreign package:

1. MemorySegment: Abstraction of off-heap memory

MemorySegment represents a continuous memory area, which can be in or out of heap, or even local memory. It is a secure encapsulation of raw memory.

 // Allocate 100 bytes of off-heap memory try (MemorySegment segment = MemorySegment.allocateNative(100)) {
    segment.set(JAVA_INT, 0, 42); // Write int at offset 0
    int value = segment.get(JAVA_INT, 0); // Read System.out.println(value); // Output 42
}

• Use allocateNative() to allocate local memory.
• Use set() / get() method to cooperate with ValueLayout (such as JAVA_INT ) for typed read and write.
• It must be used in try-with-resources to ensure that memory is released in time.

2. ValueLayout and MemoryLayout: Memory layout definition

Used to describe the layout of data structures, such as basic types, structures, arrays, etc.

 ValueLayout.OfInt INT = ValueLayout.JAVA_INT;
SequenceLayout arrayLayout = MemoryLayout.sequenceLayout(10, INT); // int[10]

These layouts can be used to build function parameter types or structure maps.

3. SymbolLookup: Find local function symbols

Used to locate function addresses in dynamic libraries.

 SymbolLookup lookup = SymbolLookup.libraryLookup("libc.so.6"); // Linux
// or SymbolLookup.libraryLookup("msvcrt.dll") on Windows

4. FunctionDescriptor and MethodHandle: Define and call external functions

FunctionDescriptor describes the parameters and return types of the function, and combines Linker to get the callable MethodHandle .

Example: Calling printf of C

 import java.lang.foreign.*;
import static java.lang.foreign.ValueLayout.*;

Linker linker = Linker.nativeLinker();
SymbolLookup stdlib = linker.defaultLookup();

// Define the printf function signature: int printf(const char*, ...)
FunctionDescriptor printfDesc = FunctionDescriptor.of(JAVA_INT, ADDRESS);

MethodHandle printf = linker.downcallHandle(stdlib.find("printf").orElseThrow(), printfDesc);

// Prepare string (must end with NULL)
try (Arena arena = Arena.ofConfined()) {
    MemorySegment format = arena.allocateFrom("Hello from %s!\n");
    MemorySegment name = arena.allocateFrom("FFM API");

    // Call printf
    printf.invoke(format, name);
}

Output:

 Hello from FFM API!

Note: The variable parameter function supports limited support. In this example, only two parameters are passed, so you need to be cautious when using it.

3. Calling a custom local library (simple example)

Suppose you have a C function:

 // libadd.so (Linux) / add.dll (Windows)
int add(int a, int b) {
    return ab;
}

After compiling into a shared library, call it in Java:

 try (Arena arena = Arena.ofConfined()) {
    Linker linker = Linker.nativeLinker();
    SymbolLookup lookup = linker.defaultLookup(); // or specify the path FunctionDescriptor addDesc = FunctionDescriptor.of(JAVA_INT, JAVA_INT, JAVA_INT);
    MethodHandle add = linker.downcallHandle(
        lookup.find("add").orElseThrow(),
        addDesc
    );

    int result = (int) add.invoke(3, 4);
    System.out.println("3 4 = " result); // Output 7
}

No need to write JNI code, it is done entirely in the Java layer.

IV. Arena: Memory life cycle management

Java 21 introduces the Arena concept to unify the life cycle of MemorySegment .

• Arena.ofConfined() : Single thread access, good performance.
• Arena.ofShared() : Multi-threaded sharing, more secure but with synchronization overhead.

 try (Arena arena = Arena.ofConfined()) {
    MemorySegment seg = arena.allocate(100);
    // Use seg...
} // Automatically release all memory

This is a key mechanism to prevent memory leaks.

5. Advantages compared to JNI

6. Current status and precautions

• The Preview feature is still in Java 21 , and the preview option needs to be enabled:

   javac --release 21 --enable-preview YourClass.java
  java --enable-preview YourClass

• The API may be adjusted in the future and is not recommended for use in production environments until they become permanent (Java 22 or 23 is expected).
• Support for complex structures (such as nested structures, unions) is being improved.
• Cross-platform compatibility requires attention to library names and calling conventions (such as stdcall for Windows).

---

Basically that's it. The Foreign Function & Memory API is an important step for Java to system-level programming, marking that Java is becoming more "close to hardware" while remaining secure and concise. It will gradually become the preferred solution for scenarios that require high-performance local calls (such as databases, AI library integrations, operating system tools).

The above is the detailed content of The Foreign Function & Memory API in Java 21. For more information, please follow other related articles on the PHP Chinese website!