Re: Static Variables and JAR Files
On Mar 3, 3:13 pm, Lew <l...@lewscanon.com> wrote:
Knute Johnson wrote:
Jason Cavett wrote:
I am curious - does the scope of static variables carry across
different JAR files?
Here's the issue:
BaseClass is in "BaseClasses.jar"
ExtendedClassA extends BaseClass is in "AnotherPackage.jar"
ExtendedClassB extends BaseClass is in "EvenAnotherPackage.jar"
BaseClass has a static object (ObjectX). Now, normally, this static
object is static across all of the subclasses. However...
These JAR files (AnotherPackage and EvenAnotherPackage) are being read
in by a separate tool. When ExtendedClassA and ExtendedClassB are
used within the context of this tool, ObjectX is instantiated twice
and has two separate values. As far as I can tell, the tool runs
ExtendedClassA and ExtendedClassB within the same JVM, so I am unsure
of what is going on.
Does anybody have any insight into what is going on here? (Sorry for
being vague. I'm not actually working the project, but I'm curious
from an academic standpoint. Another group ran across this problem
today.)
I'm curious how you instantiate a static object? What tool are they using?
The scope of a static class variable is the entire execution of the JVM once
the class is loaded. Its accessibility is that declared for it.
This isn't necessarily true. A single class Foo can be loaded in
multiple class loaders so long as the common parents do not also load
Foo. This means that static members of Foo may exist more than once:
each time the Foo class is loaded within a classloader, another
occurrence of Foo's static members comes into being . Foo's static
initializer is also run each time the class is loaded.
Consider the following class Foo:
package dyn;
public class Foo {
static {
System.out.println("Class " + Foo.class + " loaded on CL="
+ Foo.class.getClassLoader());
}
}
This class is not available on the bootstrap classpath: it's in a
separate directory called Dynamic relative to the working directory.
The main class
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;
public class DCL {
public static void main(String[] args) throws
MalformedURLException,
ClassNotFoundException, InstantiationException,
IllegalAccessException {
URLClassLoader cl1 =
new URLClassLoader(
new URL[] { new URL(
"file:Dynamic/") });
cl1.loadClass("dyn.Foo").newInstance();
URLClassLoader cl2 =
new URLClassLoader(
new URL[] { new URL(
"file:Dynamic/") });
cl2.loadClass("dyn.Foo").newInstance();
}
}
generates the output
Class class dyn.Foo loaded on CL=java.net.URLClassLoader@2e7263
Class class dyn.Foo loaded on CL=java.net.URLClassLoader@5eb0a9
Since Cavett hasn't told us what this "separate tool" is, it's
entirely possible that it's engaging in some dynamic classloading and
actually is running the static initializer for ObjectX twice (and
initializing static final members twice).
-o