64-bit JNI C++ to JAVA invocation multiple threads classloader problem

[triet kha]

Hi ALL,

I have a C++ app that invokes Java classes on 64-bit Solaris 10 with 64-bit JVM.

Here is the problem:
The native non-main (not the thread that initializes the JVM) threads would not be able to find any user-define class and run into StackOverflowError.

Here are the symptoms and observations:
1. The "main thread" that instantiates the JVM has no problem finding and loading any class or method
2. But the other threads (non-main threads) would not be able to find the user-defined classes unless the classes were already loaded by the main thread.
3. The non-main threads can find the "standard" java classes with no problem
4. The same app ran fine on 32-bit system.
5. Except for the JVM reference is global, I already have each thread acquired JNIEnv by either GetEnv() or AttachCurrentThread().
6. JNIEnv::ExceptionDescribe() showed the following StackOverflowError:

 
Exception in thread "Thread-0" java.lang.StackOverflowError
        at java.util.Arrays.copyOf(Arrays.java:2734)
        at java.util.Vector.ensureCapacityHelper(Vector.java:226)
        at java.util.Vector.addElement(Vector.java:573)
        at java.lang.ClassLoader.addClass(ClassLoader.java:173)
        at java.lang.ClassLoader.defineClass1(Native Method)
        at java.lang.ClassLoader.defineClass(ClassLoader.java:621)
        at java.security.SecureClassLoader.defineClass(SecureClassLoader.java:124)
        at java.net.URLClassLoader.defineClass(URLClassLoader.java:260)
        at java.net.URLClassLoader.access$000(URLClassLoader.java:56)
        at java.net.URLClassLoader$1.run(URLClassLoader.java:195)
        at java.security.AccessController.doPrivileged(Native Method)
        at java.net.URLClassLoader.findClass(URLClassLoader.java:188)
        at java.lang.ClassLoader.loadClass(ClassLoader.java:307)
        at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:301)
        at java.lang.ClassLoader.loadClass(ClassLoader.java:252)
        at java.lang.ClassLoader.loadClassInternal(ClassLoader.java:320)

7. Here is the sample code that reproduces the problem:

#include <string>
#include "jni.h"
#include "TestThread.h"
 
static JavaVM *g_pjvm = NULL;  /* denotes a Java VM */
static JNIEnv *g_penv = NULL;  /* pointer to native method interface */
 
void initJVM(char** jvmOptions) {
    printf("RJniTest init starts...\n");
    JavaVMInitArgs vm_args; /* JDK/JRE 6 VM initialization arguments */
    JavaVMOption* poptions;
 
    int optionLen = 0;
    while (jvmOptions[optionLen]) {
        optionLen++;
    }
    printf("RJniTest::init len=%d\n", optionLen);
    if (optionLen > 0) {
        printf("RJniWrapper::init jvmOptions\n");
        poptions = new JavaVMOption[optionLen];
        int idx = 0;
        while (jvmOptions[idx]) {
            poptions[idx].optionString = jvmOptions[idx];
            idx++;
        }
    }
    printf("RJniTest::init vm_args: version(%x), nOptions(%d)\n",
            JNI_VERSION_1_6, optionLen);
    vm_args.version = JNI_VERSION_1_6;
    vm_args.nOptions = optionLen;
    vm_args.options = poptions;
    vm_args.ignoreUnrecognized = JNI_FALSE;
    // load and initialize a Java VM, return a JNI interface
    // pointer in env
    printf("RJniTest::init creates JVM\n");
    JNI_CreateJavaVM(&g_pjvm, (void**)&g_penv, &vm_args);
    printf("RJniTest init ends\n");
}
void findClass(const char* classname) {
    static const char* fname = "justFindClasses";
    printf("%s: findClass: %s\n", fname, classname);
    JNIEnv* jenv;
    jint ret = g_pjvm->GetEnv((void**)&jenv, JNI_VERSION_1_6);
    if (ret == JNI_EDETACHED) {
        ret = g_pjvm->AttachCurrentThread((void**)&jenv, NULL);
        if (ret != JNI_OK || jenv == NULL) {
            printf("%s: get env error: ret=%d\n", ret, fname);
        } else {
            printf("%s: got new env\n", fname);
        }
    } else if (ret == JNI_OK) {
        printf("%s: env already there\n");
    }
    jclass classref;
    classref = jenv->FindClass(classname);
    if (classref == NULL) {
        printf("%s: %s class not found!\n", fname, classname);
        if (jenv->ExceptionOccurred()) {
            jenv->ExceptionDescribe();
            jenv->ExceptionClear();
        }
    }
    printf("%s: found class: %s\n", fname, classname);
}
class RJniTestThread : public TestThread {
public:
    void threadmain();
};
 
void RJniTestThread::threadmain() {
    printf("RJniTestThread::threadmain: Starting testing\n");
 
    findClass("org/apache/commons/logging/Log"); // this would fail
    findClass("java/util/List"); // this is ok
 
    printf("RJniTestThread::threadmain: done.\n");
}
 
int main(int argc, char** argv) {
    char **jvmOptions = NULL;
    printf("RJniTestDriver starts...\n");
    if (argc > 1) {
        jvmOptions = new char*[argc];
        for (int i = 0; i < argc ; i ++) {
            jvmOptions[i] = argv[i + 1];
        }
        jvmOptions[argc - 1] = NULL;
    } else {
        int size = 8;
        int i = 0;
        jvmOptions = new char*[size];
        jvmOptions[i++] = (char*) "-Djava.class.path=<list of jar files and path here>";
        jvmOptions[i++] = (char*) "-Djava.library.path=/sandbox/mxdev/3rdparty/java/unix/jdk1.6.0_14/jre/lib/sparc";
        jvmOptions[i++] = (char*) "-Djava.compiler=NONE";
        jvmOptions[i++] = (char*) "-verbose:jni";
        jvmOptions[i++] = (char*) "-Xcheck:jni";
        jvmOptions[i++] = NULL;
    }
    printf("init JVM\n");
    initJVM(jvmOptions);
 
    // UNCOMMENT HERE to have the main thread to load the classes first.
    // findClass("org/apache/commons/logging/Log");
    // findClass("java/util/List");
    // UNCOMMENT END
 
    printf("start test thread\n");
    RJniTestThread testThread;
    ThreadId tid = testThread.launch();
    printf("wait for test thread\n");
    int ret = pthread_join(tid, NULL);
    printf("RJniTestDriver ends\n");
}

Any idea why it is a problem with 64-bit?

I really appreciate it if anyone can provide any help/suggestion.

Regards,

- Triet

[triet kha]

I did more testing and found that the observation regarding 32-bit was incorrect. The simple class finding program provided above ran fine in 32-bit, but when I added more complicated operations, such as doing some work with Apache JackRabbit, I would get StackOverflowError as well.

[triet kha]

It turned out that I made a very stupid mistake. I had only focused on tuning the Java stack size and neglected the native thread stack size which was hidden by the internal thread wrapper, which has a default 64k stack size, I used. After changing the stack size to 256k, everything ran just fine.

Thanks to those who have tried to help out. I really appreciate it.