通过 JNI 从本机线程回调时 Java 线程泄漏
简介: 我看到 Java 线程泄漏时从本机创建的线程上的本机代码回调到 Java。
(2014 年 2 月 11 日更新:我们向 Oracle 提出了此请求作为支持请求。它现在已经由Oracle在Java 7 update 45上确认。它只影响64位Linux(可能还有Mac)平台:32位Linux不受影响)。
(2014 年 4 月 29 日更新:Oracle 已修复此问题,并将在 Java 7 更新 80 中发布)。
我有一个由Java层和本机库组成的应用程序。Java层通过JNI调用本机库:这会导致一个新的本机线程开始运行,该线程回调到Java中。因为新的本机线程没有附加到 JVM,所以在执行回调之前需要附加它,然后在之后分离它。通常的方法似乎是将使用 AttachCurrentThread/DetachCurrentThread 调用回 Java 的代码括起来。这工作正常,但是对于我们的应用程序(它非常频繁地回调到Java),每次附加和分离的开销都很大。
在几个地方(如这里和这里)描述了一个优化,它建议使用基于线程本地存储的机制来消除这个问题:基本上每次触发本机回调时,都会测试线程以查看它是否已经附加到JVM:如果没有,它将附加到JVM,并且线程本地存储机制用于在线程退出时自动分离线程。我已经实现了这一点,但是尽管连接和分离似乎正确发生,但这会导致Java端的线程泄漏。我相信我做对了每件事,并且正在努力看看可能出了什么问题。我已经在这个问题上捶捶了一段时间,如果有任何见解,我将不胜感激。
我以精简的形式重新创建了问题。下面是本机层的代码。我们这里有一个包装器,它封装了为当前线程返回JNIEnv指针的过程,使用POSIX线程本地存储机制自动分离线程(如果尚未附加)。有一个回调类充当 Java 回调方法的代理。(我使用了对静态Java方法的回调,以消除创建和删除对Java对象的全局对象引用的额外复杂性,这与此问题无关)。最后,有一个 JNI 方法,当它被调用时,它会构造一个回调,并创建一个新的本机线程并等待它完成。这个新创建的线程调用回调一次,然后退出。
#include <jni.h>
#include <iostream>
#include <pthread.h>
using namespace std;
/// Class to automatically handle getting thread-specific JNIEnv instance,
/// and detaching it when no longer required
class JEnvWrapper
{
public:
static JEnvWrapper &getInstance()
{
static JEnvWrapper wrapper;
return wrapper;
}
JNIEnv* getEnv(JavaVM *jvm)
{
JNIEnv *env = 0;
jint result = jvm->GetEnv((void **) &env, JNI_VERSION_1_6);
if (result != JNI_OK)
{
result = jvm->AttachCurrentThread((void **) &env, NULL);
if (result != JNI_OK)
{
cout << "Failed to attach current thread " << pthread_self() << endl;
}
else
{
cout << "Successfully attached native thread " << pthread_self() << endl;
}
// ...and register for detach when thread exits
int result = pthread_setspecific(key, (void *) env);
if (result != 0)
{
cout << "Problem registering for detach" << endl;
}
else
{
cout << "Successfully registered for detach" << endl;
}
}
return env;
}
private:
JEnvWrapper()
{
// Initialize the key
pthread_once(&key_once, make_key);
}
static void make_key()
{
pthread_key_create(&key, detachThread);
}
static void detachThread(void *p)
{
if (p != 0)
{
JavaVM *jvm = 0;
JNIEnv *env = (JNIEnv *) p;
env->GetJavaVM(&jvm);
jint result = jvm->DetachCurrentThread();
if (result != JNI_OK)
{
cout << "Failed to detach current thread " << pthread_self() << endl;
}
else
{
cout << "Successfully detached native thread " << pthread_self() << endl;
}
}
}
static pthread_key_t key;
static pthread_once_t key_once;
};
pthread_key_t JEnvWrapper::key;
pthread_once_t JEnvWrapper::key_once = PTHREAD_ONCE_INIT;
class Callback
{
public:
Callback(JNIEnv *env, jobject callback_object)
{
cout << "Constructing callback" << endl;
const char *method_name = "javaCallback";
const char *method_sig = "(J)V";
env->GetJavaVM(&m_jvm);
m_callback_class = env->GetObjectClass(callback_object);
m_methodID = env->GetStaticMethodID(m_callback_class, method_name, method_sig);
if (m_methodID == 0)
{
cout << "Couldn't get method id" << endl;
}
}
~Callback()
{
cout << "Deleting callback" << endl;
}
void callback()
{
JNIEnv *env = JEnvWrapper::getInstance().getEnv(m_jvm);
env->CallStaticVoidMethod(m_callback_class, m_methodID, (jlong) pthread_self());
}
private:
jclass m_callback_class;
jmethodID m_methodID;
JavaVM *m_jvm;
};
void *do_callback(void *p)
{
Callback *callback = (Callback *) p;
callback->callback();
pthread_exit(NULL);
}
extern "C"
{
JNIEXPORT void JNICALL Java_com_test_callback_CallbackTest_CallbackMultiThread(JNIEnv *env, jobject obj)
{
Callback callback(env, obj);
pthread_t thread;
pthread_attr_t attr;
void *status;
int rc;
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
rc = pthread_create(&thread, &attr, do_callback, (void *) &callback);
pthread_attr_destroy(&attr);
if (rc)
{
cout << "Error creating thread: " << rc << endl;
}
else
{
rc = pthread_join(thread, &status);
if (rc)
{
cout << "Error returning from join " << rc << endl;
}
}
}
Java代码非常简单:它只是在循环中重复调用本机方法:
package com.test.callback;
public class CallbackTest
{
static
{
System.loadLibrary("Native");
}
public void runTest_MultiThreaded(int trials)
{
for (int trial = 0; trial < trials; trial++)
{
// Call back from this thread
CallbackMultiThread();
try {
Thread.sleep(200);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
static void javaCallback(long nativeThread)
{
System.out.println("Java callback: native thread: " + nativeThread + ", java thread: " + Thread.currentThread().getName() + ", " + Thread.activeCount() + " active threads");
}
native void CallbackMultiThread();
}
以下是此测试的一些示例输出:您可以看到,尽管本机层报告本机线程已成功附加和分离,但每次触发回调时都会创建一个新的 Java 线程:
Constructing callback
Successfully attached native thread 140503373506304
Successfully registered for detach
Java callback: native thread: 140503373506304, java thread: Thread-67, 69 active threads
Successfully detached native thread 140503373506304
Deleting callback
Constructing callback
Successfully attached native thread 140503373506304
Successfully registered for detach
Java callback: native thread: 140503373506304, java thread: Thread-68, 70 active threads
Successfully detached native thread 140503373506304
Deleting callback
Constructing callback
Successfully attached native thread 140503373506304
Successfully registered for detach
Java callback: native thread: 140503373506304, java thread: Thread-69, 71 active threads
Successfully detached native thread 140503373506304
Deleting callback
Constructing callback
Successfully attached native thread 140503373506304
Successfully registered for detach
Java callback: native thread: 140503373506304, java thread: Thread-70, 72 active threads
Successfully detached native thread 140503373506304
Deleting callback
Constructing callback
Successfully attached native thread 140503373506304
Successfully registered for detach
Java callback: native thread: 140503373506304, java thread: Thread-71, 73 active threads
Successfully detached native thread 140503373506304
Deleting callback
补充一点:我使用的开发平台是 CentOS 6.3(64 位)。Java版本是Oracle发行版版本1.7.0_45,尽管OpenJDK发行版1.7和1.6版本也显示了问题。