JNI简易开发

JNI简易开发

Whg，20210324

1 基础配置

Oracle官方文档：

https://docs.oracle.com/javase/7/docs/technotes/guides/jni/spec/jniTOC.html

其他参考：

https://www.eg.bucknell.edu/~mead/Java-tutorial/native1.1/TOC.html#invoking

1.1 JDK

n  javac，将java文件编译成.class文件

n  javah，使用class文件生成JNI头文件h使用

n  javap，反编译器。解析class文件，输出编译信息

n  java，在jvm上运行java文件和class文件

1.2 g++、gdb、clion

       sudo apt install g++

       c++编译器，调试器

1.3 native开发使用到的jni头文件

 

2 基础介绍

2.1 java基础

        此外，还应注意java的垃圾回收机制，这会影响到jni Function的不同调用。

2.1.1 对c++的要求

       由于jvm是多线程的，native要求被编译成支持多线程，以支持jvm多线程特性

2.2 JNI基础

 

This chapter introduces the Java Native Interface (JNI). The JNI is a native programming interface. It allows Java code that runs inside a Java Virtual Machine (VM) to interoperate with applications and libraries written in other programming languages, such as C, C++, and assembly.

JNI基于jvm特性实现了java和native的互通操作，其互通操作分为2种类型：

l  JNI function，用于在java和native之间实现功能上的互通。提供了对java field、method、static等域的操作

l  Invocation API，实现了native与jvm的互通

2.2 JNI设计概览

2.2.1 JNI function

       JNI function被设计成类似c++ virtual table的二级指针结构，JNI function有以下特点：

l  JNI interface pointer内部维护了functions table，指向具体的JNi function实现

l  JNI interface pointer与线程绑定，不可跨线程访问，其使用thread-local特性实现

l  JNI interface pointer 作为native 方法的参数传入

l  Jvm保证，单线程中的多个native 方法的JNI interface pointer一致，多线程中的native方法收到的JNI interface pointer不一致

 

该设计的优点：

l  该设计具有很高的灵活度，与native的实现完全剥离

l  比如，一个jvm可以同时拥有多个JNI interface pointer的内部实现（function table），而native代码，完全不必关心JNI interface pointer内部function table的组织结构

 

JNI interface pointer的代码示例（二级指针表的结构）：

 

2.2.2 Invocation API

       Invocation API主要用作native method操作jvm，因jvm负责整体环境，所以Invocation API涉及了一些环境上的操作，如：

l  创建、销毁jvm

l  将线程与jvm注册、分离

2.2.3 JNI libraries

l  jint JNI_OnLoad(JavaVM *vm, void *reserved);

当java加载so时，jvm会调用JNI_OnLoad。JNI_OnLoad必须返回当前使用的JNI版本号，jvm对返回的版本号进行识别，指定JNI的具体实现。所以，有必要了解一下不同jni版本号的功能特性

如果native不实现JNI_OnLoad，则jvm默认版本为JNI_VERSION_1_1

如果native实现了JNI_OnLoad但返回的版本号无效，则so会加载失败

 

附：Changes in JNI 1.1.2

 

l  void JNI_OnUnload(JavaVM *vm, void *reserved);

当java加载so的class loader被垃圾回收后，jvm才调用OnUnload。该函数可用于清理native的缓存

 

下图是JNI_OnLoad、JNI_OnUnload在JNI library中的定义，以及JDK8支持支持的JNI版本类型，高16字节是大版本，低16字节是小版本

 

3 JNI基础类型和数据结构

3.1 基础类型映射

3.2 JNI reference type

       Java数据类型，除了基础数据类型外，别的几乎都是object的子类。对于java object对象，obj1 = ojb2，相当于c++ 传递reference or pointer，而非assign or construct。

3.2.1 LocalReference

局部对象引用仅存活在native method方法期间，return后自动释放referfence

如若native method占用时间太长，大对象无法得到及时释放，此时，需要显示使用DeleteLocalRef释放局部对象

3.2.2 GlobalReference

全局对象由NewGlobalRef从局部对象或者全局对象产生，局部对象只在显示调用DeleteGlobalRef后才会销毁

3.2.3 WeakReference

       WeakReference也是一种全局引用，但与GlobalReference的区别在于，weakReference指向的对象，可能会被垃圾收集器回收。

3.2.4 IsSameObject

       以上对象引用，均可以使用jbool IsSameObject(Obj1, Obj2); 判断对象引用是否有效（与NULL对比）

3.3 field id

 

3.4 method id

 

3.5 function argument array value type

 

该类型用作native调用java方法的参数列表类型使用，如

 

3.6 Type Signatures

3.6.1 argument signature

Java的filed和method都有类型签名，native调用java方法时，必须告知jvm的java method 的name和signatures，以便jvm查找到java 方法。

Java类型签名的定义：

 

可以使用javap -s参数进行查看。如：

 

3.6.2 native method signature

Java方法名称：

private native String sayHello(String msg);

由javah生成的native方法：

/*

 * Class:     HelloJNI

 * Method:    sayHello

 * Signature: (Ljava/lang/String;)Ljava/lang/String;

 */

JNIEXPORT jstring JNICALL Java_HelloJNI_sayHello (JNIEnv *, jobject, jstring);

 

Native方法名的格式如下：

l  前缀Java_

l  完整的包名HelloJNI_

l  方法名sayHello

l  如果是重载的方法，两个下划线__后紧跟参数签名

 

对于下面的方法：

class Cls1 {

  int g(int i);

  native int g(double d);

}

上述的native method g并不属于重载，因为另外一个g不是native方法

3.7 Modified UTF-8 Strings

       JNI使用修改后的UTF8格式（非标准UTF8格式）。所以，需要使用GetStringUTFChars等方法转成c++ 的string。

也可以使用GetStringUTFLength查询UTF8的长度。

4 library 操作

见2.2.3

4.1 JNI_OnLoad

       jint JNI_OnLoad(JavaVM *vm, void *reserved)

4.2 JNI_OnUnload

void JNI_OnUnload(JavaVM *vm, void *reserved)

5 jvm操作

5.1 GetEnv

       通过jvm获取当前线程的env

5.2 GetJavaVM

       通过jenv获取jvm

5.3 AttachCurrentThread

5.4 DetachCurrentThread

       JNI function与线程环境挂钩，如果native方法回调java方法时

l  已保存当前线程的JNIEnv，则使用当前线程的env调用JNI Function

l  如果未保存当前线程的JNIEnv（不考虑是主线程还是主线程），则使用GetEnv获取当前线程的JNIEnv，再执行JNI Function操作

l  使用完后，可以解除与线程的绑定。或者保存，供下次子线程调用

 

子线程attach、detach的大致过程为：

...

std::thread::id currentThreadId = std::this_thread::get_id();
    if (mainThreadId_.load() == currentThreadId) {
        DLOG(INFO) << "shell thread : async result using main thread : " <<  std::hex << currentThreadId;
        SyncResultCallback(queryText, results, candidateStartIndex, flag, highLightIndex);
        return;
    }

    if (jvm_ == nullptr) {
        DLOG(ERROR) << "shell thread : " <<  std::hex << currentThreadId << " global JavaVM is invalid ";
        return;
    }
    JNIEnv* env {nullptr};
    jint jresult = jvm_->GetEnv((void**)&env, global_jni_version);
//    if (jresult != JNI_OK || env == nullptr) {
//        return;
//    }

    jresult = jvm_->AttachCurrentThread(&env, NULL);
    if (jresult != JNI_OK) {
        DLOG(ERROR) << "thread : " <<  std::hex << currentThreadId << std::dec << ", AsyncResultCallback : cannot attach current thread, error code " << jresult;
        return;
    }

...    do something ...

jresult = jvm_->DetachCurrentThread();
    if (jresult != JNI_OK) {
        DLOG(ERROR) << "shell thread : " <<  std::hex << std::this_thread::get_id() << std::dec << ", AsyncResultCallback : cannot detach current thread, error code " << jresult;
        return;
    }

...

 

6 JNI操作

6.1 java调用native方法

       Java代码直接调用即可

6.2 native操作reference

       详细介绍见3.2节

 

l  NewGlobalRef

l  DeleteGlobalRef

l  DeleteLocalRef

l  EnsureLocalCapacity

l  PushLocalFrame

l  PopLocalFrame

l  NewLocalRef

l  NewWeakGlobalRef

l  DeleteWeakGlobalRef

 

6.3 native访问java field

如访问：

 

 

 

实现步骤：

1. 使用GetObjectClass（thisObj）获取jclass
2. 使用GetFieldID（jclass， filed name， field signature）获取jfieldid
3. 使用GetObjectField（object， fieldid）获取field的值

l  GetFieldID

l  Get<type>Field Routines

l  Set<type>Field Routines

 

l  GetStaticFieldID

l  GetStatic<type>Field Routines

l  SetStatic<type>Field Routines

6.4 native访问java method

如native访问java的方法

实现步骤：

1. 使用GetObjectClass（thisObj）获取jclass
2. 使用GetMethodId（jclass， method name，method signature）获取jmethodid
3. 使用CallMethodID（object, methodid, argument）访问method

l  Call<type>Method Routines

l  Call<type>MethodA Routines,

l  Call<type>MethodV Routines

 

l  CallNonvirtual<type>Method Routines

l  CallNonvirtual<type>MethodA Routines

l  CallNonvirtual<type>MethodV Routines

 

l  GetStaticMethodID

l  CallStatic<type>Method Routines

l  CallStatic<type>MethodA Routines

l  CallStatic<type>MethodV Routines

6.5 native操作jstring

l  NewString

l  GetStringLength

l  GetStringChars

l  ReleaseStringChars

l  NewStringUTF

l  GetStringUTFLength

l  GetStringUTFChars

l  ReleaseStringUTFChars

l  GetStringRegion

l  GetStringUTFRegion

l  GetStringCritical

l  ReleaseStringCritical

6.6 native操作jarray

l  GetArrayLength

l  NewObjectArray

l  GetObjectArrayElement

l  SetObjectArrayElement

l  New<PrimitiveType>Array Routines

l  Get<PrimitiveType>ArrayElements Routines

l  Release<PrimitiveType>ArrayElements Routines

l  Get<PrimitiveType>ArrayRegion Routines

l  Set<PrimitiveType>ArrayRegion Routines

l  GetPrimitiveArrayCritical

l  ReleasePrimitiveArrayCritical

6.7 native操作java exception

l  Throw

l  ThrowNew

l  ExceptionOccurred

l  ExceptionDescribe

l  ExceptionClear

l  FatalError

l  ExceptionCheck

6.8 native访问java class

l  DefineClass

l  FindClass

l  GetSuperclass

l  IsAssignableFrom

6.9 native操作java object

l  AllocObject

l  NewObject, NewObjectA, and NewObjectV

l  GetObjectClass

l  GetObjectRefType

l  IsInstanceOf

l  IsSameObject

6.10 java操作native class

一般流程：

1：通过static native方法创建native类实例，将native 类地址（int）返回给java

2：native同时提供出带指针地址的方法

3：java调用步骤2的native方法，将1中获取的类地址作为参数传递

4：native方法收到类地址时，使用类型转换将地址转为class类型，紧跟调用类对应方法

如下所示，nativeInterface为native创建的类地址

JNI_GENERATOR_EXPORT jboolean
    Java_com_Interface_nativeNMethod(JNIEnv* env, jobject
    jcaller,
    jlong nativeInterface,
    jstring languageToken) {
  Interface* native = reinterpret_cast<Interface*>(nativeInterface);
  CHECK_NATIVE_PTR(env, jcaller, native, "NMethod", false);
  return native->NMethod(env, base::android::JavaParamRef<jobject>(env,
      jcaller), base::android::JavaParamRef<jstring>(env,param));
}

 

7 JNI测试-HelloJNI为例

 

源文件HelloJNI.java：

import java.util.Scanner;

public class HelloJNI {  // Save as HelloJNI.java
   static {
      System.load("/mnt/hgfs/workspace/self/java/jni/libHelloJNI.so"); // Load native library hello.dll (Windows) or libhello.so (Unixes)
                                   //  at runtime
                                   // This library contains a native method called sayHello()
   }

   final static int integer = 1;
   final private String string = "abc";
   // Declare an instance native method sayHello() which receives no parameter and returns void
   private native String sayHello(String msg);
   private native void callbackEntry(String msg);
   private native void getJavaFiled();
   private native void localReference();
   private native void localReferenceRelease();
   private native void globalReference();
   private native void globalReferenceRelease();
   private native void weakGlobalReference();
   private native void weakGlobalReferenceRelease();
   private native void arraySum(int[] array);
   private native void catchThrow() throws IllegalArgumentException;

   // Test Driver
   public static void main(String[] args) {
    HelloJNI helloJNI = new HelloJNI();

    Scanner input = new Scanner(System.in);
    String val = input.next();
    do {
        if (val != null) {
            if (val.equals("callJavaMethod")) {
                // call java method
                helloJNI.callbackEntry("callbackEntry from java");
            } else if (val.equals("getJavaField")) {
                // access java member variables
                helloJNI.getJavaFiled();
            } else if (val.equals("catchThrow")) {
                boolean exceptionOccur = false;
                // catch and throw exception
                try {
                    helloJNI.catchThrow();
                }
                catch(Exception e) {
                    exceptionOccur = true;
                    System.out.println("catch native exception, show call stack");
                    e.printStackTrace();
                }
                finally {
                    //
                    if (exceptionOccur) {
                        System.out.println("recover from exception");
                    }
                }
            } else if (val.equals("localReference")) {
                helloJNI.localReference();
            } else if (val.equals("localReferenceRelease")) {
                helloJNI.localReferenceRelease();
            } else if (val.equals("globalReference")) {
                helloJNI.globalReference();
            } else if (val.equals("globalReferenceRelease")) {
                helloJNI.globalReferenceRelease();
            } else if (val.equals("weakReference")) {
                helloJNI.weakGlobalReference();
            } else if (val.equals("weakReferenceRelease")) {
                helloJNI.weakGlobalReferenceRelease();
            } else if (val.equals("arraySum")) {
                helloJNI.arraySum(new int[]{1,2,3,4,5,6});
            } else {
                // Accessing Java Strings
                String str = helloJNI.sayHello(val);
                System.out.println("return native str : " + str);
            }
        }
        System.out.println("-------------------------------------------------");
        val = input.next();
    } while(!val.equals("exit"));
    input.close();
   }

   private String CallbackByNative(String str, int strLength) {
        return "native str callback: " + str + ", length :" + Integer.toString(strLength);
   }

   private void catchThrowByJava() throws NullPointerException {
       throw new NullPointerException("thrown in CatchThrow.callback");
     }
}

 

源文件Hello JNI.cpp

#include <iostream>    // C++ standard IO header
#include "HelloJNI.h"  // Generated
#include <cstring>
using namespace std;

//JNIEXPORT jstring JNICALL NativeCallJavaMethod(JNIEnv *env, jobject thisObj, const char* str) {
//    // get java class name
//    jclass cls = env->GetObjectClass(thisObj);
//    // use class method by class name, method name, signature
//    jmethodID jmethodId = env->GetMethodID(cls, u8"CallbackByNative", u8"(Ljava/lang/String;I)Ljava/lang/String;");
//    if (jmethodId == NULL) {
//        return NULL;
//        // method not found
//    }
//    // new native str
//    size_t strLength = std::strlen(str);
//    char* newStr = new char[strLength + 1];
//    memcpy(newStr, str, strLength);
//    memset(newStr + strLength, 0, 1);
//    jstring newJavaStr = env->NewStringUTF(newStr);                     // new string
//    // call java method by object, method, params
//    jstring javaResult = (jstring)env->CallObjectMethod(thisObj, jmethodId, newJavaStr, strLength);
//    // jstring to native str
//    char* nativeStr = (char*)env->GetStringUTFChars(javaResult, NULL);    // native str trans from java string
//    printf("result str from java callback : %s\n", nativeStr);
//    env->ReleaseStringUTFChars(javaResult, nativeStr);
//    delete [] newStr;
//}

// In order to use any of the new JNI functions, a native library must export a JNI_OnLoad function that returns JNI_VERSION_1_2.
// If the native library does not export a JNI_OnLoad function, the VM assumes that the library only requires JNI version JNI_VERSION_1_1.
JNIEXPORT jint JNI_OnLoad(JavaVM *vm, void *reserved) {
    JNIEnv* env = NULL;
    jint ret = vm->AttachCurrentThread(reinterpret_cast<void **>(&env), NULL);
    printf("JNI_OnLoad\n");
    std::flush(std::cout);
    return JNI_VERSION_1_6;
}

JNIEXPORT void JNI_OnUnload(JavaVM *vm, void *reserved) {
    printf("JNI_OnUnload\n");
    std::flush(std::cout);
}

// Implementation of the native method sayHello()
JNIEXPORT jstring JNICALL Java_HelloJNI_sayHello(JNIEnv *env, jobject thisObj, jstring jstr) {
    // get jni version
    jint version = env->GetVersion();
    // get java str length(UTF8)
    jsize jstrLeng = env->GetStringLength(jstr);                    // str length
    jsize jstrLengUTF8 = env->GetStringUTFLength(jstr);             // str UTF8 length : if char is chinese, UTF8length = length * 3
    char* str = (char*)env->GetStringUTFChars(jstr, NULL);    // native str trans from java string
    printf("jni version : 0x%x, echo : %s, length : %d, utf8 length : %d\n", version, str, jstrLeng, jstrLengUTF8);
    env->ReleaseStringUTFChars(jstr, str);                           // must release utf string
    return jstr;
}

JNIEXPORT void JNICALL Java_HelloJNI_callbackEntry(JNIEnv *env, jobject thisObj, jstring jstr) {
    // get java class name
    jclass cls = env->GetObjectClass(thisObj);
    // use class method by class name, method name, signature
    // TODO : Obtaining a method ID is a relatively expensive operation.
    // TODO : Because you obtain the method ID separately from the method invocation, you need only perform this operation once.
    // TODO : Thus, it is possible to first obtain the method ID one time and then use the method ID many times at later points to invoke the same method.
    jmethodID jmethodId = env->GetMethodID(
            cls,
            u8"CallbackByNative",
            u8"(Ljava/lang/String;I)Ljava/lang/String;"
    );
    if (jmethodId == NULL) {
        return;
        // method not found
    }
    // call java method by object, method, params
    jstring javaResult = (jstring)env->CallObjectMethod(
            thisObj,
            jmethodId,
            jstr,
            env->GetStringLength(jstr)
    );
    char* str = (char*)env->GetStringUTFChars(javaResult, NULL);    // native str trans from java string
    printf("callback java result, trans to UTF8 str: %s\n", str);
    env->ReleaseStringUTFChars(javaResult, str);                           // must release utf string
}

JNIEXPORT void JNICALL Java_HelloJNI_getJavaFiled(JNIEnv *env, jobject thisObj) {
    jclass cls = env->GetObjectClass(thisObj);
    // access static int
    jfieldID jfieldId = env->GetStaticFieldID(cls, "integer", "I");
    if (jfieldId == NULL) {
        return;
    }
    jint jint1 = env->GetStaticIntField(cls, jfieldId);
    printf("java class integer is assigned to %d\n", jint1);
    // access member string
    jfieldId = env->GetFieldID(cls, "string", "Ljava/lang/String;");
    if (jfieldId == NULL) {
        return;
    }
    jstring jstring1 = (jstring)env->GetObjectField(thisObj, jfieldId);
    char* str = (char*)env->GetStringUTFChars(jstring1, NULL);    // native str trans from java string
    printf("java object string is assigned to %s\n", str);
    env->ReleaseStringUTFChars(jstring1, str);                           // must release utf string
}

JNIEXPORT void JNICALL Java_HelloJNI_catchThrow(JNIEnv *env, jobject thisObj) {
    jclass cls = env->GetObjectClass(thisObj);
    // use class method by class name, method name, signature
    jmethodID jmethodId = env->GetMethodID(cls, u8"catchThrowByJava", u8"()V");
    if (jmethodId == NULL) {
        return;
        // method not found
    }
    env->CallVoidMethod(thisObj, jmethodId);
    jthrowable exception = env->ExceptionOccurred();
    if (exception != NULL) {
        printf("detect java method exception, print call stack : \n");
        env->ExceptionDescribe();       // Prints an exception and a backtrace of the stack to a system error-reporting channel, such as stderr. This is a convenience routine provided for debugging.
        env->ExceptionClear();          // clear exception
    }
    // throw exception from native
    jclass nativeException = env->FindClass("java/lang/IllegalArgumentException");
    if (nativeException == 0) { /* Unable to find the new exception class, give up. */
        return;
    }
    env->ThrowNew(nativeException, "thrown exception from native");   // throw new java exception
}

// TODO : This program is illegal because the local reference returned from GetObjectClass is valid only until the native method returns.
// TODO : When the Java application calls the native method Java_FieldAccess_accessFields a second time, the native method tries to use an invalid local reference.
// TODO : This leads to either the wrong results or to a VM crash.
jstring l_jstring = NULL;
JNIEXPORT void JNICALL Java_HelloJNI_localReference(JNIEnv *env, jobject thisObj) {
    if (l_jstring == NULL) {
        l_jstring = (jstring)env->GetObjectField(thisObj,
                                                env->GetFieldID(
                                                        env->GetObjectClass(thisObj),
                                                        "string",
                                                        "Ljava/lang/String;"
                                                )
        );
    }
    char* str = (char*)env->GetStringUTFChars(l_jstring, NULL);    // native str trans from java string
    printf("java object string is assigned to %s\n", str);
    env->ReleaseStringUTFChars(l_jstring, str);                           // must release utf string
}

JNIEXPORT void JNICALL Java_HelloJNI_localReferenceRelease(JNIEnv *env, jobject thisObj) {
    if (l_jstring != NULL) {
        env->DeleteLocalRef(l_jstring);
        l_jstring = NULL;
    }
}

jstring g_jstring = NULL;
JNIEXPORT void JNICALL Java_HelloJNI_globalReference(JNIEnv *env, jobject thisObj) {
    if (g_jstring == NULL) {
        jstring jstring1 = (jstring)env->GetObjectField(
                thisObj,
                env->GetFieldID(
                        env->GetObjectClass(thisObj),
                        "string",
                        "Ljava/lang/String;"
                )
        );
        g_jstring = (jstring)env->NewGlobalRef(jstring1);
        // test IsSameObject
        jstring test = (jstring)env->NewGlobalRef(jstring1);
        if (env->IsSameObject(test, g_jstring) == JNI_TRUE) {
            int a = 0;
        }
    }
    char* str = (char*)env->GetStringUTFChars(g_jstring, NULL);    // native str trans from java string
    printf("java object string is assigned to %s\n", str);
    env->ReleaseStringUTFChars(g_jstring, str);                           // must release utf string
}

JNIEXPORT void JNICALL Java_HelloJNI_globalReferenceRelease(JNIEnv *env, jobject thisObj) {
    if (g_jstring != NULL) {
        env->DeleteGlobalRef(g_jstring);
        g_jstring = NULL;
    }
}

jweak g_weak = NULL;
void Java_HelloJNI_weakGlobalReference(JNIEnv *env, jobject thisObj) {
    if (env->IsSameObject(g_weak, NULL) == JNI_FALSE) {
        printf(" weak reference point is valid, underlying object is still valid\n");
        char* str = (char*)env->GetStringUTFChars((jstring)g_weak, NULL);    // native str trans from java string
        printf("java object string is assigned to %s\n", str);
        env->ReleaseStringUTFChars((jstring)g_weak, str);                           // must release utf string
    } else {
        printf(" weak reference point to NULL, create new one \n");
        if (g_jstring == NULL) {
            jstring jstring1 = (jstring)env->GetObjectField(thisObj,
                                                            env->GetFieldID(
                                                                    env->GetObjectClass(thisObj),
                                                                    "string",
                                                                    "Ljava/lang/String;"
                                                            )
            );
            g_jstring = (jstring)env->NewGlobalRef(jstring1);
            g_weak = env->NewWeakGlobalRef(g_jstring);
            if (env->IsSameObject(g_jstring, g_weak)) {
                int a = 0;
            }
        }
    }
}

void Java_HelloJNI_weakGlobalReferenceRelease(JNIEnv *env, jobject thisObj) {
    if (g_weak != NULL) {
        env->DeleteWeakGlobalRef(g_weak);
        g_weak = NULL;
    }
}

void Java_HelloJNI_arraySum(JNIEnv * env, jobject thisObj, jintArray intArray) {
    int  sum = 0;
    jsize len = env->GetArrayLength(intArray);
    // begin to end
    jint *arrayBody = env->GetIntArrayElements(intArray, 0);
    for (int i = 0; i < len; ++i) {
        sum += arrayBody[i];
    }
    printf("jintarrry sum result: %d\n", sum);
    env->ReleaseIntArrayElements(intArray, arrayBody, 0);
    // array region,for big array
    int* arrayRegion = new int[3];
    env->GetIntArrayRegion(intArray, 1, 3, arrayRegion);
    sum = 0;
    if (arrayRegion != NULL) {
        for (int i = 0; i < 3; ++i) {
            sum += arrayRegion[i];
        }
        printf("jintarrry[1,3] sum result: %d\n", sum);
    }
    std::flush(std::cout);
    delete [] arrayRegion;
}

7.1 javac生成HelloJNI.class

 javac HelloJNI.java

7.2 javah生成HelloJNI.h头文件

 javah HelloJNI

7.3 实现c++代码，编译so

或者使用g++生成so

g++ --shared HelloJNI.cpp -o libHelloJNI.so -I/usr/lib/jvm/java-8-openjdk-amd64/include -I/usr/lib/jvm/java-8-openjdk-amd64/include/linux

7.4 java执行HelloJNI

 java HelloJNI

7.5 查找进程id

7.6 attach debug