从JVM清除所有已加载的类

Question

I created a JVM via JNI like below:

bool JavaVM_Create(Jvm* &ptr, int argc, const char* argv[])
{
    bool result = false;
    if (!ptr && argc > 0)
    {
        ptr = new Jvm();
        JavaVMInitArgs jvm_args;
        JavaVMOption* options = new JavaVMOption[argc];

        for (int i = 0; i < argc; ++i)
        {
            options[i].optionString = const_cast<char*>(argv[i]);
        }

        JNI_GetDefaultJavaVMInitArgs(&jvm_args);

        jvm_args.version = JNI_VERSION_1_8;
        jvm_args.nOptions = 2;
        jvm_args.options = options;
        jvm_args.ignoreUnrecognized = false;

        result = true;

        jint num_vms = 0;
        JavaVM* vms[5] = {0};
        if (JNI_GetCreatedJavaVMs(vms, 5, &num_vms) == JNI_OK)
        {
            if (num_vms > 0)
            {
                ptr->vm = vms[0];
                ptr->vm->AttachCurrentThread();
                delete[] options;
                return result;
            }
        }

        if (!ptr->createJVM(&jvm_args))
        {
            result = false;
        }
        delete[] options;
    }
    return result;
}

void JavaVM_Free(Jvm* &ptr)
{
    if (ptr && ptr->vm)
    {
        ptr->vm->DetachCurrentThread();
        ptr->vm->DestroyJavaVM();
    }

    delete ptr;
    ptr = nullptr;
}

The reason why I use JNI_GetCreatedJavaVMs is to fix the bug in the JDK where it states:

jint DestroyJavaVM(JavaVM *vm);

Unloads a Java VM and reclaims its resources. The support for DestroyJavaVM was not complete in JDK/JRE 1.1. As of JDK/JRE 1.1 Only the main thread may call DestroyJavaVM. Since JDK/JRE 1.2, any thread, whether attached or not, can call this function. If the current thread is attached, the VM waits until the current thread is the only non-daemon user-level Java thread. If the current thread is not attached, the VM attaches the current thread and then waits until the current thread is the only non-daemon user-level thread. The JDK/JRE still does not support VM unloading, however .

Because of this, I'm not able to "create, destroy, create, destroy, repeat". Instead, I have to create, keep instance around for the app's lifetime and only destroy that one instance when my application is about to close.

This sucks because if I want to load two different jars into the JVM, I can't. They may or may not have classes that are the same name. Memory usage sky-rockets.

Thus, I'm trying to find a way to either unload the JVM completely (destroy it) or unload all classes that was loaded (reset it).

Any ideas or solutions?

Answer 1

The simplest way to do this is to start a new process which you destroy which finished.

Another solution is to use a ClassLoader to load the classes you want to later unload. When a ClassLoader is unloaded, all it's classes are freed up.

BTW You can have multiple ClassLoaders loaded at once, even loading different version of the same classes.

IMHO Trying to create and destroy JVMs from JNI is very tricky to get right (though not as tricky as it used to be) and I would only do this as a last resort. There many be any number of way to achieve what you want which is much simpler.