Class unloading doesn't work as described in this forum !!!

Question

Hi,
to the problem of dynamic class unloading many people in this forum wrote:
- write your own class loader
- load the class to be unloaded later
- set all instances of your own class loader to null
- if the work is done set all instances of the loaded classes to null
- call the garbage collector and the classes will be removed
I constructed a simple test for the problem:
- the test class
public class Impl {
public String getVersion () {
return "1";
- instanciating the test class
- printing the value of getVersion() to the screen
- changing the return value of getVersion() and recompiling it (the test application is still runnig)
- unload try (see below)
- instanciating the test class
- printing the value of getVersion() to the screen
Back to the tipps above. Why doing this? The theory says a class loader stores every loaded class for
suppressing unnecessary reloads. In reality the classes are NOT stored in the own class loader but in
the parent of it. If no parameter is given to a class loader's constructor the parent of a class loader
is the system classloader.
Let's have a look at the source code of java.lang.ClassLoader.loadClass(...):
protected synchronized Class loadClass(String name, boolean resolve)
throws ClassNotFoundException
// First, check if the class has already been loaded
Class c = findLoadedClass(name);
if (c == null) {
try {
if (parent != null) {
### here the loadClass() of the parent is called and the
### loaded class is stored within the parent
c = parent.loadClass(name, false);
} else {
c = findBootstrapClass(name);
} catch (ClassNotFoundException e) {
// If still not found, then call findClass in order
// to find the class.
c = findClass(name);
if (resolve) {
resolveClass(c);
return c;
My Idea was: Give a null to the class loader's constructor so the classes cannot be stored within a parent.
Here my test class loader (it is build as it is described within javadoc of java.lang.ClassLoader
except the constructor):
import java.io.*;
public class MyClassLoader extends ClassLoader {
public MyClassLoader () {
super ( null );
public Class findClass ( String name ) {
byte[] b = loadClassData ( name );
return defineClass ( name, b, 0, b.length );
private byte[] loadClassData ( String name ) {
byte[] ret = null;
try {
InputStream in = new FileInputStream ( name + ".class" );
ret = new byte[in.available ()];
in.read ( ret );
} catch ( Exception e ) {
e.printStackTrace ();
return ret;
The loading of the class works fine
ClassLoader cl = new MyClassLoader ();
Class c = cl.loadClass ( "Impl" );
Object i = c.newInstance ();
Impl impl = (Impl)i;
The class "Impl" was found and instanciated. But the cast "Impl impl = (Impl)i;" causes a
"java.lang.ClassCastException: Impl"
May second idea was deleting all instances of the class to unload from the class loader via reflection.
A strange way I know but if this is the only way I will do it. But this doesn't work too.
After deleting the class from the class loader and all its parents the class is still anywhere in the depth
of the VM.
Can anybody help me with this problem?
Thanks in advance,
Axel.

Answer 1

<pre>
I made a similar and simpler program and it worked:
import java.net.URLClassLoader;
import java.net.URL;
public class DynamicExtension {
     public static void main(String args[]) throws Exception {
          URL[] ua = new URL[] {  new URL("file://c:\\TEMP\\") };
          URLClassLoader ucl = new URLClassLoader(ua);
          MyLoadable l =
               (MyLoadable) ucl.loadClass("LoadableObject").newInstance();
          l.printVersion();
          Thread.currentThread().sleep(10000);
//you have ten seconds to replace the old version of the LoadableObject.class file
//so yo?d better had compiled the new one before executing this
          ucl = new URLClassLoader(ua);
          l = (MyLoadable) ucl.loadClass("LoadableObject").newInstance();
          l.printVersion();
          ucl = null;
          l = null;
          System.gc();
public class LoadableObject implements MyLoadable {
     public void printVersion() {
          System.out.println("version 1");
     protected void finalize() {
          System.out.println("finalizing " + this);
public interface MyLoadable {     void printVersion();  }
C:\Java\TIJ2\Test>java DynamicExtension
version 1
version 2
finalizing LoadableObject@1bd03e
finalizing LoadableObject@4abc9
The ClassCastException was due to the fact that one class was loaded by the system class loader, the one that appers as Impl impl = (Impl), and the other by MyClassLoader. That mean that they are different for the VM because they are in different namespaces: The namespace for MyClassLoader is the set of classes loaded by itself and those returned to it by his parent class loader as a result of a request to MyClassLoader?s parent class loader to load a class.
Setting null for the parent of MyClassLoader was in fact the cause of the problem, because that caused a call to a native method called findBoostrapClass. I guess this method looks for the classes in the bootstrap classpath where MyClassLoader shouldn?t be. This causes MyClassLoader loaded the class itself. If MyClassLoader had had the system class loader as its parent the result had been that only one classloader would have loaded the class. This is what happens in the example above so no ClassCastException is thrown.
In the source code for ClassLoader
there is the following:
* The classes loaded by this class loader. The only purpose of this
* table is to keep the classes from being GC'ed until the loader
* is GC'ed.
private Vector classes = new Vector(); /*
and:
* Called by the VM to record every loaded class with this loader.
void addClass(Class c) {
classes.addElement(c);
I would like to have seen findLoadedClass checking the already loaded classes in this Vector, but this method is native. Anyway, as the code for loadClass shows, the parent or bootstrap classloader is checked if findLoadedClass doesn?t find the class; Can we guess that findLoadedClass only checks the clases loaded by the classloader, not its parent?
By the way, could an example like this be made in c++?
</pre>