Native methods in java – Java Native Interface (JNI)

Mudassir Shahzad
On January 29, 2013

java.lang.Object class defined like

public native int hashCode(); // without any body

1	public native int hashCode(); // without any body

Now, in spite of having two years of hands on experience in java and related technologies, I didn’t know that it is a native method. This made me dig deeper and explore the native interface API provided by java. So, there goes

A brief introduction

Simply put, a native method is the Java interface to non-Java code. It is Java’s link to the “outside world”. Native methods are written in a “native” language other than java. This would normally use C to write the methods, but a lot of other languages, such as python allows you to write methods, too. Native methods are implemented mostly in C and compiled to native code which runs directly on the machine. This is in contrast to normal methods, which are implemented in Java and compiled to Java byte code, which is executed by the Java Virtual Machine (JVM). To use the native code, we need the Java Native Interface api.

Image courtesy :
JNI

Advantages of using Native methods

1 – Performance

In a few rare cases, proven performance benefit (because you know your particular C compiler can optimise some particular code better than the JVM’s JIT compiler)

2 – Access to platform specific infrastructure

When platform specific infrastructure (facilities of the operating system) are required, which is not provided in standard java libraries. This can be the low level stuff, i.e. in case of hashCode native method, the address of the object in memory.

3 – Reusability

When some library or code already written in C/C++ is required, and you want to use it without porting it to java code.

4 – MultiLinguality

Most real software systems are multilingual; that is, they consist of components developed in different programming languages. Developers can reuse existing code modules, and can also mix and match strengths of different languages. As an example, imagine that a developer intends to perform data compression in Java. Instead of writing all the code for data compression from scratch, he can reuse the existing ZLib C library and write a thin interface between Java and C, via the Java Native Interface (JNI).

Disadvantages

1 – Possible loss of safety

The safety and security of the JVM is lost, i.e. your program might crash or have security holes due to bugs in the native code.

2 – Low portability

The code is not portable instead it is used through an interface.

3 – Low Codeability

The native code is not in java which causes the codeability to be low. Now to manage that code you will need a person having both java and c/c++ skills.

4 – JNI call overhead

Compared to a pure Java method call, calling a user-written native method usually has a significant overhead. The reasons for this are as much to do with optimisations that the JVM can’t make compared to regular Java methods. JVM doesn’t know much about the native method. For example, it has to assume that all of the parameters passed in are always used.