[Pattern]

[IanDarwin]

Category

language

Slug

call-c-from-java

Title

Calling out to C code from Java

Difficulty

advanced

Since JDK

22

Summary

Simplifies C/C++ code to be called from Java, allowing most existing libraries to be used without adapters or cumbersome C code modification.

Old code label

Java 1.1+

Old code

public class CallCFromJava {
	static { System.loadLibrary("hello-jni"); }
	public static native int greet(String name);
	public static void main(String[] args) {
		int ret = greet("Bambi");
		System.out.println("Return value " + ret);
	}
}

Then run javac -h, then view the generated .h file, then write your .c file:

#include "CallCFromJava.h"

JNIEXPORT int JNICALL Java_CallCFromJava_greet(JNIEnv *env, jclass this, jstring str) {
	const char* name = (*env)->GetStringUTFChars(env, str, NULL);
	printf("Hello %s\n", name);
	return 0;
}

Modern code label

Java 22+

Modern code

public class CallCFromJava {
  void main() throws Throwable {

    try (Arena arena = Arena.ofConfined()) {
      SymbolLookup ourLib = 
        SymbolLookup.libraryLookup("libhello-ffi.so", arena);
      Optional<MemorySegment> segment = ourLib.find("greet");
      MemorySegment foreignFuncAddr = segment.get();
      FunctionDescriptor greet_sig= // return and input parameter
          FunctionDescriptor.of(ValueLayout.JAVA_LONG, ValueLayout.ADDRESS);
      MethodHandle greetMethod =
        Linker.nativeLinker().downcallHandle(foreignFuncAddr, greet_sig);
      var ret = (long) greetMethod.invokeExact(arena.allocateFrom("Bambi"));
      System.out.println("Return value " + ret);
    }
  }
}

C Code:
int greet(char* name) {
    printf("Hello %s\n", name);
    return 0;
}

Explanation

Java has two techniques for interfacing between Java and C/C++ code, the traditional JNI and the newer FFM. With JNI you simply declare your method as native, but then you have to run javac -h to generate a C-language .h (header) file, then have your C code implement that, and deal with the slightly cumbersome JNI C-language API.

FFM simplifies the C code to the point that it doesn't have to know anything about Java. This makes it much easier to interface with existing C/C++-language libraries. It does take a few more lines of Java code, but the net effect is more readable and more maintainable. Compare the C code in both versions and you'll see the difference!

Minimal runnable demo can be found at https://github.com/IanDarwin/javaevolved-java_callling_c

Why the modern way wins

👁 Better readability — C code doesn't have to learn Java!
⚡ More flexible - can directly call most existing C/C++ libraries
⚡ Easier - don't have to stop, run javac -h, and implement the "interface" defined in .h file.

[brunoborges]

@IanDarwin what do you think of this code snippet for the Modern side?

void main() throws Throwable {

    try (var arena = Arena.ofConfined()) {
        // Use a system library to prove FFM compiles and links
        var stdlib = Linker.nativeLinker().defaultLookup();
        var foreignFuncAddr = stdlib.find("strlen").orElseThrow();
        var strlen_sig =
            FunctionDescriptor.of(ValueLayout.JAVA_LONG, ValueLayout.ADDRESS);
        var strlenMethod =
            Linker.nativeLinker().downcallHandle(foreignFuncAddr, strlen_sig);
        var ret = (long) strlenMethod.invokeExact(arena.allocateFrom("Bambi"));
        IO.println("Return value " + ret);
    }

}