Java 高階 —— native 關鍵字與 JNI_mb5fdb0a4002420的技術博客詳情 - java,開發語言,JNI,Java,JVM,JavaScript,前端開發晨曦微露s 博客

1. native 層多線程與 JVM 交互

1.1 native 層啓動線程

在 JNI 中，native 層可以創建自己的線程（如 pthread、std::thread），但這些線程不是 JVM 線程，不能直接訪問 JVM 資源。
必須 attach 到 JVM，才能安全調用 Java 對象或方法。

1.2 attach/detach 線程

JavaVM* jvm; // 全局保存 JavaVM 指針

// 線程函數
void* thread_func(void* arg) {
    JNIEnv* env;
    // 線程 attach 到 JVM
    (*jvm)->AttachCurrentThread(jvm, (void**)&env, NULL);

    // 可以安全訪問 Java 對象和方法
    // ...

    // 線程結束前 detach
    (*jvm)->DetachCurrentThread(jvm);
    return NULL;
}

JavaVM* jvm; // 全局保存 JavaVM 指針

// 線程函數
void* thread_func(void* arg) {
    JNIEnv* env;
    // 線程 attach 到 JVM
    (*jvm)->AttachCurrentThread(jvm, (void**)&env, NULL);

    // 可以安全訪問 Java 對象和方法
    // ...

    // 線程結束前 detach
    (*jvm)->DetachCurrentThread(jvm);
    return NULL;
}

注意：

attach 後才能用 JNI API。
detach 前必須釋放所有局部引用。
多線程下要小心全局引用的併發安全（加鎖）。

1.3 native 層回調 Java（多線程）

通過全局引用保存回調對象，native 線程 attach 後用 CallVoidMethod/CallStaticMethod 調用 Java 方法。
回調後及時刪除局部引用，防止內存泄漏。

2. 複雜對象的 JNI 傳遞與構造

2.1 Java 傳對象給 native

Java：

public class Person {
    public int age;
    public String name;
}
public native void processPerson(Person p);

public class Person {
    public int age;
    public String name;
}
public native void processPerson(Person p);

C：

jclass cls = (*env)->GetObjectClass(env, person);
jfieldID fid_age = (*env)->GetFieldID(env, cls, "age", "I");
jint age = (*env)->GetIntField(env, person, fid_age);

jfieldID fid_name = (*env)->GetFieldID(env, cls, "name", "Ljava/lang/String;");
jstring jname = (jstring)(*env)->GetObjectField(env, person, fid_name);
// 轉換為 C 字符串
const char* cname = (*env)->GetStringUTFChars(env, jname, NULL);
// ...
(*env)->ReleaseStringUTFChars(env, jname, cname);

jclass cls = (*env)->GetObjectClass(env, person);
jfieldID fid_age = (*env)->GetFieldID(env, cls, "age", "I");
jint age = (*env)->GetIntField(env, person, fid_age);

jfieldID fid_name = (*env)->GetFieldID(env, cls, "name", "Ljava/lang/String;");
jstring jname = (jstring)(*env)->GetObjectField(env, person, fid_name);
// 轉換為 C 字符串
const char* cname = (*env)->GetStringUTFChars(env, jname, NULL);
// ...
(*env)->ReleaseStringUTFChars(env, jname, cname);

2.2 native 構造 Java 對象並返回

C：

jclass cls = (*env)->FindClass(env, "Person");
jmethodID ctor = (*env)->GetMethodID(env, cls, "<init>", "()V");
jobject obj = (*env)->NewObject(env, cls, ctor);

jfieldID fid_age = (*env)->GetFieldID(env, cls, "age", "I");
(*env)->SetIntField(env, obj, fid_age, 25);

// 返回 obj 給 Java
return obj;

jclass cls = (*env)->FindClass(env, "Person");
jmethodID ctor = (*env)->GetMethodID(env, cls, "<init>", "()V");
jobject obj = (*env)->NewObject(env, cls, ctor);

jfieldID fid_age = (*env)->GetFieldID(env, cls, "age", "I");
(*env)->SetIntField(env, obj, fid_age, 25);

// 返回 obj 給 Java
return obj;

2.3 複雜數組/集合的傳遞

對於 Java List/Map，native 層一般用反射方式訪問元素，效率較低。
性能敏感時建議用數組（如 int[]、Object[]），native 層用 GetObjectArrayElement 操作。

3. Java Lambda 與 JNI

3.1 Java Lambda 本質

Lambda 是編譯期自動生成的匿名類對象，實現了目標接口（如 Runnable、Function）。
JNI 層看到的是普通的 Java 對象。

3.2 JNI 層調用 Lambda

JNI 層可接收 lambda 作為參數，只要用接口類型聲明。
JNI 通過反射/接口調用，調用 lambda 的方法（如 run、apply）。

示例：

public native void useCallback(Runnable r);
useCallback(() -> System.out.println("Hello from Lambda!"));

public native void useCallback(Runnable r);
useCallback(() -> System.out.println("Hello from Lambda!"));

C：

jclass cls = (*env)->GetObjectClass(env, runnable);
jmethodID mid = (*env)->GetMethodID(env, cls, "run", "()V");
(*env)->CallVoidMethod(env, runnable, mid);

jclass cls = (*env)->GetObjectClass(env, runnable);
jmethodID mid = (*env)->GetMethodID(env, cls, "run", "()V");
(*env)->CallVoidMethod(env, runnable, mid);

3.3 侷限與注意

Lambda 不能直接在 native 層定義或實現。
native 層只能把 lambda 當作普通對象處理，不能享受 Java 層類型推斷等語法糖。
性能敏感場景下，頻繁回調 lambda 會有 JNI 橋接開銷。

4. JNI 性能基準測試與優化

4.1 性能測試方法

使用 JMH（Java Microbenchmark Harness）寫基準測試，比較 Java 方法、JNI 方法、JNA 方法的調用耗時。
典型測試：循環調用百萬次，測量總耗時。

JMH 示例：

@Benchmark
public void testJavaAdd() {
    int a = 1, b = 2;
    int c = a + b;
}

@Benchmark
public void testJNIAdd() {
    nativeAdd(1, 2);
}

@Benchmark
public void testJavaAdd() {
    int a = 1, b = 2;
    int c = a + b;
}

@Benchmark
public void testJNIAdd() {
    nativeAdd(1, 2);
}

4.2 常見性能瓶頸

JNI 方法調用有固定的橋接開銷（幾十到幾百納秒）。
數據類型轉換（如字符串、數組）開銷大。
頻繁創建/釋放引用、反射操作等會拖慢性能。

4.3 優化建議

減少 JNI 調用次數：能批量處理就批量，避免頻繁小操作。
緩存 class/methodID：避免每次都查找。
用直接緩衝區（DirectByteBuffer）：大數據傳遞更高效。
避免不必要的數據拷貝：如數組可用 GetPrimitiveArrayCritical。
合理管理引用：用完及時釋放局部/全局引用。
選擇合適的傳遞方式：複雜結構建議序列化或用 protobuf/C結構體映射。

5. 典型面試題與實戰解析

native 層多線程調用 Java 方法有什麼注意事項？

線程必須 attach/detach，回調對象需全局引用，注意併發安全。

如何從 native 層構造 Java 對象並返回？

用 FindClass、GetMethodID、NewObject、SetXXXField。

lambda 作為回調參數傳給 native，JNI 如何調用？

當作接口對象，反射調用相應方法（如 run/apply）。

JNI 性能瓶頸主要在哪？如何優化？

橋接和數據轉換開銷大，建議批量處理、緩存 methodID、用直接緩衝區。

6. native 層多線程最佳實踐

6.1 多線程安全 attach/detach

獲取 JavaVM 指針：在 JNI_OnLoad 裏全局保存 JavaVM 指針，供所有 native 線程使用。
線程 attach：每個 native 線程首次需要 attach 到 JVM，獲得 JNIEnv 指針。
線程 detach：線程退出前 detach，避免 JVM 資源泄露。

示例：

JavaVM* g_jvm = NULL;

jint JNI_OnLoad(JavaVM* vm, void* reserved) {
    g_jvm = vm;
    return JNI_VERSION_1_6;
}

void* worker(void* arg) {
    JNIEnv* env;
    if ((*g_jvm)->AttachCurrentThread(g_jvm, (void**)&env, NULL) == 0) {
        // 使用 env 調用 Java 方法
        // ...
        (*g_jvm)->DetachCurrentThread(g_jvm);
    }
    return NULL;
}

JavaVM* g_jvm = NULL;

jint JNI_OnLoad(JavaVM* vm, void* reserved) {
    g_jvm = vm;
    return JNI_VERSION_1_6;
}

void* worker(void* arg) {
    JNIEnv* env;
    if ((*g_jvm)->AttachCurrentThread(g_jvm, (void**)&env, NULL) == 0) {
        // 使用 env 調用 Java 方法
        // ...
        (*g_jvm)->DetachCurrentThread(g_jvm);
    }
    return NULL;
}

6.2 併發安全的回調

回調對象需用 NewGlobalRef 創建全局引用，避免被 GC 回收。
回調時加鎖（如 pthread_mutex），確保多線程安全。
回調後及時 DeleteGlobalRef，避免內存泄漏。

7. 複雜對象高效傳遞與映射

7.1 批量數據結構傳遞

對於大量數據（如點、向量、結構體），建議用 ByteBuffer 或直接數組傳遞，native 層按內存結構解析。
可用 Java 的 DirectByteBuffer，native 層用 GetDirectBufferAddress 獲得指針，零拷貝高性能。

Java：

ByteBuffer buf = ByteBuffer.allocateDirect(1024);
nativeProcessBuffer(buf);

ByteBuffer buf = ByteBuffer.allocateDirect(1024);
nativeProcessBuffer(buf);

C：

void JNICALL nativeProcessBuffer(JNIEnv* env, jobject obj, jobject buffer) {
    void* ptr = (*env)->GetDirectBufferAddress(env, buffer);
    // 直接操作內存
}

void JNICALL nativeProcessBuffer(JNIEnv* env, jobject obj, jobject buffer) {
    void* ptr = (*env)->GetDirectBufferAddress(env, buffer);
    // 直接操作內存
}

7.2 複雜對象序列化

對於複雜 Java 對象（如 Map/List），可以用 JSON、protobuf、flatbuffers 序列化後傳遞到 native 層，native 層反序列化為 C 結構體。
這樣可以避免 JNI 的反射遍歷，提高性能和靈活性。

8. lambda 在高性能場景下的實戰建議

8.1 場景分析

Java 層傳遞 lambda 作為回調，native 層保存並在事件發生時回調。
性能敏感時，建議只傳遞接口對象，避免頻繁回調和反射。

8.2 高效回調設計

native 層只保存接口對象的全局引用，不做多餘的類型檢查。
回調時直接用 methodID 調用，不用每次查找。
如果回調次數極多，可設計事件隊列，由 Java 層統一處理，減少 JNI 交互頻率。

9. JNI 性能基準測試與分析

9.1 JMH 基準測試示例

@Benchmark
public void javaMethod() {
    // 普通 Java 方法
}

@Benchmark
public void jniMethod() {
    nativeMethod();
}

@Benchmark
public void jniArrayMethod() {
    nativeArrayMethod(new int[1000]);
}

@Benchmark
public void javaMethod() {
    // 普通 Java 方法
}

@Benchmark
public void jniMethod() {
    nativeMethod();
}

@Benchmark
public void jniArrayMethod() {
    nativeArrayMethod(new int[1000]);
}

測試結論：

普通 Java 方法最快。
JNI 方法有橋接開銷，單次調用比 Java 慢幾十到幾百納秒。
傳遞數組/對象時，JNI 開銷更大，建議批量處理。

9.2 優化建議

批量處理：如 1000 個點一次傳遞，避免 1000 次 JNI 調用。
緩存 class/methodID：只查找一次，後續直接用。
DirectByteBuffer/序列化：大數據零拷貝或高效解析。
避免反射和頻繁創建引用。

10. JNI 在實際項目中的架構建議

10.1 封裝 native 層 API

Java 層只暴露簡單的 native 方法，參數類型儘量基礎（如數組、ByteBuffer）。
native 層用 C/C++ 封裝複雜邏輯，統一管理線程和資源，避免 Java 層直接暴露覆雜對象。

10.2 資源和異常管理

所有 native 層分配的內存和引用都需及時釋放。
native 層出錯時及時 ThrowNew Java 異常，不讓 JVM 崩潰。

10.3 跨平台適配

動態庫需分別編譯 Windows/Linux/macOS，接口保證一致性。
可用 CMake/autotools 管理多平台構建。

11. 典型面試題解析（補充）

如何用 JNI 實現 Java 層的事件回調？

保存回調對象的全局引用，native 事件發生時 attach 線程並調用 Java 方法。

批量數據高效傳遞的最佳實踐？

用 DirectByteBuffer 或 protobuf 序列化，native 層直接解析內存。

native 多線程併發安全的關鍵點？

attach/detach 線程，回調對象用全局引用，操作時加鎖。

JNI 性能優化的核心原則？

減少調用次數，批量處理，緩存查找結果，零拷貝傳遞。

11. 總結

JNI 支持 native 層多線程、複雜對象交互、Java lambda 回調等高級用法，但需嚴格管理線程、引用和資源。
性能優化需關注調用次數、數據傳遞方式和引用管理。
工程實踐中建議只在必要場景使用 JNI，儘量封裝好接口，簡化 Java 與 native 的交互。
JNI 高級用法需關注多線程安全、複雜對象高效傳遞、回調機制、性能基準與優化。
工程實踐中建議封裝好接口，統一管理資源和異常，保證跨平台一致性和高性能。
面試和項目中，能用 DirectByteBuffer、序列化、全局引用等技巧，往往體現高級水平。

本文章為轉載內容，我們尊重原作者對文章享有的著作權。如有內容錯誤或侵權問題，歡迎原作者聯繫我們進行內容更正或刪除文章。

博客 / 詳情

Java 高階 —— native 關鍵字與 JNI_mb5fdb0a4002420的技術博客