One thing to remember about JNI is that it creates a bit of overload to parse in and out of JVM. But depending on the task, this is not necessarily enough downside to keep away from it. The best way to figure out whether or not to use C/C++ or Java, is to test your task in both and then compare the result.
One good example of a task better suited for JNI could be some extensive file operations. For this example we will collect the content of the stat file for all currently running processes on a device. On my device running Android 5, we are talking about rounded 300 files. We add this to a loop which will run 100 times which in turn will create 3000 file read operations.
The first thing we need, is a basic activity to run our examples in.
MainActivity.java:
public class MainActivity extends Activity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
StringBuilder builder = new StringBuilder();
for (int i=0; i < 2; i++) {
double start = System.nanoTime();
int files = 0;
for (int x=0; x < 100; x++) {
String[] list = null;
switch (i) {
case 0: list = JavaCollector.collect(); break;
case 1: list = NativeCollector.collect();
}
files += list.length;
}
double end = System.nanoTime();
builder.append(i == 0 ? "JavaCollector" : "NativeCollector\n");
builder.append("Files = " + files + "\n");
builder.append("Time = " + ((end - start) * Math.pow(10, -9)) + " seconds\n");
builder.append("\n");
}
TextView view = (TextView) findViewById(R.id.textview);
view.setText(builder.toString());
}
}
We also need a Java method to do the collection work. We will separate the native method and the Java method into two files in this example. It makes it easier to keep an overview.
JavaCollector.java:
public class JavaCollector {
/*
* Re-defined regexp to match directories in /proc with process id's
*/
protected static final Pattern REFEXP_PID = Pattern.compile("^[0-9]+$");
/*
* The method that collects all the file data
*/
public static String[] collect() {
/*
* Get a listing from the /proc directory
*/
String[] procListing = new File("/proc").list();
/*
* Define our input stream
*/
BufferedReader in = null;
/*
* Create a temp container for the file output
*/
ArrayList<String> lines = new ArrayList<String>();
/*
* Handle each entity in /proc
*/
for (String procEntity : procListing) {
/*
* We only want the pid directories
*/
if (REFEXP_PID.matcher(procEntity).matches()) {
try {
/*
* Open the sub directory stat file
*/
in = new BufferedReader(new FileReader("/proc/" + procEntity + "/stat"));
/*
* Get the content of the stat file
*/
lines.add(in.readLine());
} catch (IOException e) {} finally {
if (in != null) {
try {
/*
* Close the file
*/
in.close();
in = null;
} catch (IOException e) {}
}
}
}
}
/*
* Create and return a string array
*/
return lines.toArray( new String[ lines.size() ] );
}
}
And we cannot compare the above Java class to JNI without a native example as well.
NativeCollector.java:
public class NativeCollector {
/*
* Load our collector library
*/
static {
System.loadLibrary("collector");
}
/*
* This is really a call to Java_com_example_NativeCollector_collect() in collector.cpp
*/
public static native String[] collect();
}
collector.cpp:
JNIEXPORT jobjectArray JNICALL Java_com_example_NativeCollector_collect(JNIEnv *env, jobject thisObj) {
/*
* Open /proc
*/
DIR* procDirectory = opendir("/proc");
if (procDirectory != NULL) {
/*
* Create a temp container with minimum 100 indexes pre-allocated
*/
std::vector<std::string> lines(100);
/*
* Create an input stream
*/
std::ifstream in;
/*
* Create a variable for the proc entities
*/
struct dirent* procEntity;
/*
* Handle each entity in /proc
*/
while ((procEntity = readdir(procDirectory)) != NULL) {
/*
* We only want the pid directories
*/
if (std::regex_match (procEntity->d_name, std::regex("^[0-9]+$") )) {
/*
* Open the sub directory stat file
*/
std::string path = std::string("/proc/") + procEntity->d_name + "/stat";
in.open( path.c_str() );
if (in && in.good()) {
/*
* Get the content of the stat file
*/
std::string line;
std::getline(in, line);
lines.push_back(line);
}
/*
* Close the file
*/
if (in) {
in.close();
}
}
}
/*
* Create Java return data
*/
if (lines.size() > 0) {
/*
* Create a Java array
*/
jobjectArray ret = env->NewObjectArray(lines.size(), env->FindClass("java/lang/String"), NULL);
for (int i=0; i < lines.size(); i++) {
/*
* Place the line in a Java String
*/
jstring stringObject = env->NewStringUTF( lines[i].c_str() );
/*
* Add the Java String to the Java Array
*/
env->SetObjectArrayElement(ret, i, stringObject);
/*
* Release the Java String reference.
*
* Note: This is important. We can only have a limited ammount of Java objects
* at a time and they are not auto released until we return to the JVM. And since we
* are looping an unknown, but large, number of files, we could end up with a memory overflow.
*/
env->DeleteLocalRef(stringObject);
}
/*
* Return the array to JVM
*/
return ret;
}
}
/*
* Return an empty array
*/
return env->NewObjectArray(0, env->FindClass("java/lang/String"), NULL);;
}
If we compile and run this application, we will get the following result:
- JavaCollector$collect: 21.2 seconds
- NativeCollector$collect: 2.7 seconds
This is not just slightly faster than Java, this is 87% faster.
This is only a simple example. If it should be used in a real application, then depending on the amount of files and amount of data, it might be a good idea to make some sort of iteration mechanism to avoid memory overflow. But as the result shows, it is sometimes a good idea to check whether or not a JNI solution might be better. Java is not always the correct solution.
So get started with:
- Learning C/C++
- Learning JNI
- Setup your NDK
- Bookmark the C++ manual and the JNI manual
