Reputation: 16541
While playing this puzzle (It's a Java keyword trivia game), I came across the native
keyword.
What is the native keyword in Java used for?
Upvotes: 549
Views: 264902
Reputation: 384304
Minimal runnable example
Main.java
public class Main {
public native int square(int i);
public static void main(String[] args) {
System.loadLibrary("Main");
System.out.println(new Main().square(2));
}
}
Main.c
#include <jni.h>
#include "Main.h"
JNIEXPORT jint JNICALL Java_Main_square(
JNIEnv *env, jobject obj, jint i) {
return i * i;
}
Compile and run:
sudo apt-get install build-essential openjdk-7-jdk
export JAVA_HOME='/usr/lib/jvm/java-7-openjdk-amd64'
javac Main.java
javah -jni Main
gcc -shared -fpic -o libMain.so -I${JAVA_HOME}/include \
-I${JAVA_HOME}/include/linux Main.c
java -Djava.library.path=. Main
Output:
4
Tested on Ubuntu 14.04 AMD64. Also worked with Oracle JDK 1.8.0_45.
Example on GitHub for you to play with.
Underscores in Java package / file names must be escaped with _1
in the C function name as mentioned at: Invoking JNI functions in Android package name containing underscore
Interpretation
native
allows you to:
This could be used to:
with the tradeoff of lower portability.
It is also possible for you to call Java from C, but you must first create a JVM in C: How to call Java functions from C++?
Analogous native extension APIs are also present in many other "VM languages" for the same reasons, e.g. Python, Node.js, Ruby.
Android NDK
The concept is exact the same in this context, except that you have to use Android boilerplate to set it up.
The official NDK repository contains "canonical" examples such as the hello-jni app:
In you unzip
an .apk
with NDK on Android O, you can see the pre-compiled .so
that corresponds to the native code under lib/arm64-v8a/libnative-lib.so
.
TODO confirm: furthermore, file /data/app/com.android.appname-*/oat/arm64/base.odex
, says it is a shared library, which I think is the AOT precompiled .dex corresponding to the Java files in ART, see also: What are ODEX files in Android? So maybe the Java is actually also run via a native
interface?
Example in the OpenJDK 8
Let's find find where Object#clone
is defined in jdk8u60-b27.
We will conclude that it is implemented with a native
call.
First we find:
find . -name Object.java
which leads us to jdk/src/share/classes/java/lang/Object.java#l212:
protected native Object clone() throws CloneNotSupportedException;
Now comes the hard part, finding where clone is amidst all the indirection. The query that helped me was:
find . -iname object.c
which would find either C or C++ files that might implement Object's native methods. It leads us to jdk/share/native/java/lang/Object.c#l47:
static JNINativeMethod methods[] = {
...
{"clone", "()Ljava/lang/Object;", (void *)&JVM_Clone},
};
JNIEXPORT void JNICALL
Java_java_lang_Object_registerNatives(JNIEnv *env, jclass cls)
{
(*env)->RegisterNatives(env, cls,
methods, sizeof(methods)/sizeof(methods[0]));
}
which leads us to the JVM_Clone
symbol:
grep -R JVM_Clone
which leads us to hotspot/src/share/vm/prims/jvm.cpp#l580:
JVM_ENTRY(jobject, JVM_Clone(JNIEnv* env, jobject handle))
JVMWrapper("JVM_Clone");
After expanding a bunch of macros, we come to the conclusion that this is the definition point.
Upvotes: 541
Reputation: 74661
native
is a keyword in Java, it indicates platform dependent.native
methods act as an interface between Java (JNI) and other programming languages.Upvotes: 6
Reputation: 835
Java native
method provides a mechanism for Java code to call OS native code, either due to functional or performance reasons.
Example:
606 public native int availableProcessors();
617 public native long freeMemory();
630 public native long totalMemory();
641 public native long maxMemory();
664 public native void gc();
In the corresponding Runtime.class
file in OpenJDK, located in JAVA_HOME/jmods/java.base.jmod/classes/java/lang/Runtime.class
, contains these methods and tagged them with ACC_NATIVE
(0x0100
), and these methods do not contain the Code attribute, which means these method do not have any actual coding logic in the Runtime.class
file:
availableProcessors
: tagged as native and no Code attributefreeMemory
: tagged as native and no Code attributetotalMemory
: tagged as native and no Code attribute maxMemory
: tagged as native and no Code attribute gc
: tagged as native and no Code attributeThe in fact coding logic is in the corresponding Runtime.c file:
42 #include "java_lang_Runtime.h"
43
44 JNIEXPORT jlong JNICALL
45 Java_java_lang_Runtime_freeMemory(JNIEnv *env, jobject this)
46 {
47 return JVM_FreeMemory();
48 }
49
50 JNIEXPORT jlong JNICALL
51 Java_java_lang_Runtime_totalMemory(JNIEnv *env, jobject this)
52 {
53 return JVM_TotalMemory();
54 }
55
56 JNIEXPORT jlong JNICALL
57 Java_java_lang_Runtime_maxMemory(JNIEnv *env, jobject this)
58 {
59 return JVM_MaxMemory();
60 }
61
62 JNIEXPORT void JNICALL
63 Java_java_lang_Runtime_gc(JNIEnv *env, jobject this)
64 {
65 JVM_GC();
66 }
67
68 JNIEXPORT jint JNICALL
69 Java_java_lang_Runtime_availableProcessors(JNIEnv *env, jobject this)
70 {
71 return JVM_ActiveProcessorCount();
72 }
And these C
coding is compiled into the libjava.so
(Linux) or libjava.dll
(Windows) file, located at JAVA_HOME/jmods/java.base.jmod/lib/libjava.so
:
Reference
Upvotes: 8
Reputation: 1237
NATIVE is Non access modifier.it can be applied only to METHOD. It indicates the PLATFORM-DEPENDENT implementation of method or code.
Upvotes: 9
Reputation: 888177
The native
keyword is applied to a method to indicate that the method is implemented in native code using JNI (Java Native Interface).
Upvotes: 366
Reputation: 8410
It marks a method, that it will be implemented in other languages, not in Java. It works together with JNI (Java Native Interface).
Native methods were used in the past to write performance critical sections but with Java getting faster this is now less common. Native methods are currently needed when
You need to call a library from Java that is written in other language.
You need to access system or hardware resources that are only reachable from the other language (typically C). Actually, many system functions that interact with real computer (disk and network IO, for instance) can only do this because they call native code.
See Also Java Native Interface Specification
Upvotes: 437
Reputation: 87
native is a keyword in java , which is used to make unimplemented structure(method) like as abstract but it would be a platform dependent such as native code and execute from native stack not java stack.
Upvotes: 7
Reputation: 19011
functions that implement native code are declared native.
The Java Native Interface (JNI) is a programming framework that enables Java code running in a Java Virtual Machine (JVM) to call, and to be called by, native applications (programs specific to a hardware and operating system platform) and libraries written in other languages such as C, C++ and assembly.
http://en.wikipedia.org/wiki/Java_Native_Interface
Upvotes: 13
Reputation: 30868
Straight from the Java Language Specification:
A method that is
native
is implemented in platform-dependent code, typically written in another programming language such as C, C++, FORTRAN,or assembly language. The body of anative
method is given as a semicolon only, indicating that the implementation is omitted, instead of a block.
Upvotes: 61