总结：在本机创建的线程上从本机代码回调到Java时，我看到Java线程泄漏。
（2014年2月11日更新：我们将此作为对Oracle的支持请求提出。现在Oracle已经confirmed在Java 7更新45上。它只影响64位Linux（可能还有Mac）平台： 32位Linux不受影响。）
（2014年4月29日更新：Oracle已解决此问题，并将在Java 7更新80中发布。）
我有一个由Java层和本机库组成的应用程序。 Java层通过JNI调用本机库：这会导致新的本机线程开始运行，后者将调用回Java。由于新的本机线程未附加到JVM，因此需要在执行回调之前将其附加，然后再分离。通常的方法是使用AttachCurrentThread / DetachCurrentThread调用将回调到Java的代码括起来。这样可以正常工作，但对于我们的应用程序（非常频繁地调用Java），每次附加和分离的开销都很大。
在几个地方（如here和here）中描述了一种优化，它建议使用基于线程本地存储的机制来消除此问题：基本上每次触发本机回调时，线程测试它是否已经附加到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。
答案 0 :(得分：6)
Oracle已经使用JVM解决了这个问题，它将在Java 7更新80中发布。
如果你不接受自己的答案，也许你会接受这个答案。 至少它不会再为零回答问题吸引尽可能多的流量。