Multiple instances of static variables

Question

I'm experimenting with using different classloaders to load a particular class, and see if the static variables in that class can have different instances.

Basically, I'm trying to write code for what Stephen C has mentioned in this answer.

Here are my classes:

CustomClassLoader.java

class CustomClassLoader extends ClassLoader
{
    public Class loadClass(String classname)  throws ClassNotFoundException {
        return super.loadClass(classname, true);
    }
}

Test.java (which contains the driver)

class Test {
        public static void main(String[] args) throws Exception {
                CustomClassLoader c1 = new CustomClassLoader();
                CustomClassLoader  c2 = new CustomClassLoader();
                Class m1, m2;

                m1 = c1.loadClass("A");
                m2 = c2.loadClass("A");

                m1.getField("b").set(null, 10);

                System.out.println(m1.getField("b").get(null));
                System.out.println(m2.getField("b").get(null));
        }

}

A.java (which contains the static variable)

class A {
        public static int b = 5;
}

When I run the Test class, I get the following output:

$ java Test
10
10

I expected the output to be 10 and 5. How can I make the code create two instances of my static variable?

Note: I'm doing this only for experimentation and learning - but I'd be interested to know if there could be any real world application of this.

Paul Cager · Accepted Answer · 2011-05-10T12:52:51.713

8

It looks as though the class "A" is being loaded by the parent class loader, rather than your CustomClassLoader (because you call super.loadClass).

The following untested amendment should allow you to define the "A" class using your own class loader (while delegating everything else to the parent loader).

Apologies for the horrible bodge where I assume the single inputStream.read() will read everything! But you can hopefully see what I mean.

    public Class loadClass(String classname)  throws ClassNotFoundException {
    if (classname.equals("A")) {
        InputStream is = getResourceAsStream("A.class");
        byte[] bodge = new byte[8192];  // Should read until EOF
        try {
            int len = is.read(bodge);
            return defineClass("A", bodge, 0, len);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    return super.loadClass(classname, true);
}

You'll probably then end up with ClasscastExceptions or something similar...

edited May 10 '11 at 12:52

answered May 10 '11 at 12:33

Paul Cager

1,910
14
21

Thanks, Paul. I'll try to load the classes without calling `super.loadClass()`. Could you recommend any good resource that explains that? – AbdullahC May 10 '11 at 12:40
I've updated my answer above. I'm afraid I don't know any good tutorials other than http://www.javaworld.com/javaworld/jw-10-1996/jw-10-indepth.html. – Paul Cager May 10 '11 at 12:55
Your code compiles perfectly, but I get the following exception on lines that either set or get `b`: `Exception in thread "main" java.lang.IllegalAccessException: Class Test can not access a member of class A with modifiers "public static"`. – AbdullahC May 11 '11 at 03:48
Thanks, it worked and printed out different values for the static variable when I made class `A` public. – AbdullahC May 11 '11 at 04:22

score 6 · Answer 2 · answered May 10 '11 at 12:41

Your problem is that new CustomClassLoader() creates a classloader that will try to delegate loading classes to the system classloader - and that will be the same for both instances. Your CustomClassLoader also isn't even able to load classes itself. Try using an URLClassLoader and passing null as parent.

As for real world applications: it's essential for Java Web containers and app servers by allowing different apps to be completely isolated from each other even though they may be using many of the same classes.

Thanks for your additional comment on the real world applications. — AbdullahC, May 11 '11 at 04:24

deve · Answer 3 · 2017-12-31T08:28:04.040

I had the same problem (integration tests) and tried it with @Michael Borgwardt approach. Here some example code:

URLClassLoader classLoader1 = new URLClassLoader(new URL[]{new URL("file:///path/to/jar/my-classes.jar")}, null);
URLClassLoader classLoader2 = new URLClassLoader(new URL[]{new URL("file:///path/to/jar/my-classes.jar")}, null);

// Load with classLoader1
Class<?> myClass1 = classLoader1.loadClass("MyClass");
Constructor<?> constructor1 = myClass1.getConstructor();
Object instance1 = constructor1.newInstance();

// Load with classLoader2
Class<?> myClass2 = classLoader2.loadClass("MyClass");
Constructor<?> constructor2 = myClass2.getConstructor();
Object instance2 = constructor2.newInstance();

// Load with system classloader
MyClass myClass = new MyClass();

// ...

score 0 · Answer 4 · answered May 10 '11 at 12:45

0

If you look at the ClassLoader source or even javadocs you'll find out that by default the ClassLoader delegates to the default system ClassLoader, which in fact is shared among the instances.

answered May 10 '11 at 12:45

Mikko Wilkman

1,495
10
8

Ummm... unless you use a classloader like URLClassLoader without a parent loader. I do this a lot to create isolated runtime environments within jvms (primarily for testing). – Ajax Jun 30 '16 at 02:01

Multiple instances of static variables

4 Answers4

Linked