JVM PermGen Class Loading & Unloading Concern

Hi All,
My application is spitting out lot of following statements periodically:
[Loaded sun.reflect.GeneratedMethodAccessor833 from __JVM_DefineClass__] ..
and ocassionally,
[Unloading class sun.reflect.GeneratedMethodAccessor1220]
My application uses lot of RMI and serialization & desrialization process. Initially, it was causing my application to slow down and later on we did the following:
- Increased the PermGen space.
- Tune the Garbage Collection Policy for Heap (Enabled ConcurrentMarkSweepGC and ParNewGC)
After making above changes, we have restarted the application and not experienced slowness again (though we are still monitoring the application). But above statements are still visible, I have following questions:
- Why "GeneratedMethodAccessor" is being loaded again and again? I guess these are required for accessing or invoking methods on serialized objects and proxy. But aren't they cached as reference in the main class that was loaded by JVM?
- Does "Unloading class sun.reflect.GeneratedMethodAccessor1220" happen only after full GC runs? In actual, when it actually starts unloading these references?
Any help shall be really appreciated?

To add to the above, the classes get unloaded if they are collected. To be collected they must be eligible. And the only way that happens if the following are both true.
1. The class loader is eligible for collection.
2. There are no active references.

Similar Messages

GC performance and Class Loading/Unloading

We have EP 6.0, SP11 on Solaris with JDK 1.4.8_02. We are running Web Dynpro version of MSS/ESS and Adobe Document Services. This is a Java stack only Web AS.
We are experiencing very uneven performance on the Portal. Usually, when the Portal grinds to a halt, the server log shows GC entries or Class unloading entries for the entire time the Portal stops working.
I am thinking about setting the GC parameters to the same size to try and eliminate sudden GC interruptions. Also, what parameter can I set to allow as many classes to be loaded at startup and stay in memory for as long as possible?
Thanks,
Rob Bartlett

Hi Robert
Also, if the host running the WebAS is a multi processor machine, then setting the flags
-XX:+UseConcMarkSweepGC and
-XX:+UseParNewGC
will help reduce the pause time during the GC collection in old generation and the young genereation respectively, as the GC will happen using multiple threads
I can suggest you to check if the GC performs a minor collection or major collection by enabling the flags
-verbose:gc
-XX:+PrintGCTimeStamps
-XX:+PrintGCDetails. Based on this, try to tune the young or old generation.
Regards
Madhu

RMI Class Loader

Hi, i Have an application which uses RMI and I need to change at runtime the codebase property to point to a local directory which is not on the CLASSPATH environment variable, so the JVM default Class Loader cannot load the classes located at that local directory. I guess I have to define my own subclass of the class java.rmi.server.RMIClassLoaderSpi and in my code I should change the property "java.rmi.server.RMIClassLoaderSpi" with the method System.setProperty() to point to another RMIClassLoaderSpi subclass as needed, right?
I found the documentation of the class RMIClassLoaderSpi too vague. Can anyone tell me what code to place on which of her methods? An example would be great.

I would suggest another simple approach - launch a new VM for every user application.
I looked at the RMI implementation (you can also download the J2SDK source code and see how internal sun.* classes are implemented) and it looks like you will get the correct codebase annotation if you load your user classes with a URLClassLoader.
Now if you want to use a dynamic codebase property you can have your own RMIClassLoaderSpi. It has a method "getClassAnnotation" which you can implement to return any codebase you wish for your classes.
Genady

Dynamic Class Loading and Unloading

I am trying to create a system where the class name and method name is
picked up from a meta-data database and executed.
This was accompanied using Dynamic Class loading. I tried to extend this to
support versioning of meta-data. Here depending on the version of meta-data
different libraries can be loaded and different implementations of object
with the same name can be executed. This does not seem to work with Forte
3.0.
When the second Library is loaded the method execution does not work.
(Even though the unload flag on the LoadLibrary is set)
If the application is stopped and restarted pointing to the second library
there is no problem. In a running application a dynamically loaded library
does not seem to unload and reload a new library for the same class names.
Has anyone tried sometime similar, is there a workaround for this type of
problem.
- Vivek

I am trying to create a system where the class name and method name is
picked up from a meta-data database and executed.
This was accompanied using Dynamic Class loading. I tried to extend this to
support versioning of meta-data. Here depending on the version of meta-data
different libraries can be loaded and different implementations of object
with the same name can be executed. This does not seem to work with Forte
3.0.
When the second Library is loaded the method execution does not work.
(Even though the unload flag on the LoadLibrary is set)
If the application is stopped and restarted pointing to the second library
there is no problem. In a running application a dynamically loaded library
does not seem to unload and reload a new library for the same class names.
Has anyone tried sometime similar, is there a workaround for this type of
problem.
- Vivek

Problem lies some where JVM Class Loader

I suspect that the jar files are in the JPI cache. During applet initialization, the various classes start loading. Then, because of the page trasition,
the applet gets shutdown by the Java Plug In. Because it doesn't terminate quickly enough, the JPI starts killing threads (java.lang.ThreadDeath).
The classloader seems to be ungraceful in handling that situation. This seems to leave the classloader's internal state in an inconsitent state.
Therefore, until the JVM is restarted, the class loading fails.
Thanks and Regards
Manoja

I suspect that the jar files are in the JPI cache. During applet initialization, the various classes start loading. Then, because of the page trasition,
the applet gets shutdown by the Java Plug In. Because it doesn't terminate quickly enough, the JPI starts killing threads (java.lang.ThreadDeath).
The classloader seems to be ungraceful in handling that situation. This seems to leave the classloader's internal state in an inconsitent state.
Therefore, until the JVM is restarted, the class loading fails.
Thanks and Regards
Manoja

Dynamic Class Loading in an EJB Container

Hello,
We have a need to load classes from a nonstandard place with in an ejb container, ie a database or secure store. In order to do so we have created a custom class loader. Two issues have come up we have not been able to solve, and perhaps some one knows the answer to.
Issue 1.
Given the following code:
public static void main(String args[])
MyClassLoader loader = new MyClassLoader("lic.dat");
System.out.println("Loading class ..." + "TestObject");
Object o = Class.forName("TestObject",true,loader).newInstance();
System.out.println("Object:" + o.toString());
TestObject tstObj = (TestObject) o;
tstObj.doIt();
What happens when executed is as follows. Class.forName calls our loader and does load the class as we hoped, it returns it as well, and the o.toString() properly executes just fine. The cast of the object to the actual TestObject fails with a class not found exception. We know why this happens but don't know what to do about it. It happens because the class that contains main was loaded by the system class loader (the primordial class loader as its sometimes called), That class loader does not know about TestObject, so when we cast even though the class is "loaded" in memory the class we are in has no knowledge of it, and uses its class loader to attempt to find it, which fails.
> So the question is how do you let the main class know to use our class loader instead of
the system class loader dispite the fact is was loaded by the system class loader.
Issue 2:
To make matters worse we want to do this with in an EJB container. So it now begs the question how do you inform an EJB container to use a specific class loader for some classes?
Mike...

Holy crap! We are in a similar situation. In creating a plugin engine that dynamically loads classes we use a new class loader for each plugin. The purpose is so that we can easily unload and/or reload a class at runtime. This is a feature supposedly done by J2EE app servers for hot-deploy.
So our plugins are packaged as JAR files. If you put any class in the CLASSPATH, the JVM class loader (or the class loader of the class that is loading the plugin(s)), will load the class. The JavaDoc API states that the parent classloader is first used to see if it can find the class. Even if you create a new URLClassLoader with NULL for parent, it will always use the JVM class loader as its parent. So, ideally, in our couse, plugins will be at web sites, network drives, or outside of the classpath of the application and JVM.
This feature has two benefits. First, at runtime, new updates of plugins can be loaded without having to restart the app. We are even handling versions and dependencies. Second, during development, especially of large apps that have a long startup time, being able to reload only one plugin as opposed to the annoying startup time of Java apps is great! Speeds up development greatly.
So, our problem sounds just like yours. Apparently, the Client, which creates an instance of the plugin engine, tries to access a plugin (after the engine loades it via a new classloader instance for each plugin). Apparently, it says NoDefClassFound, because as you say, the client classloader has no idea about the plugin class loaded by another classloader.
My co-developer came up with one solution, which I really dont like, but seems to be the only way. The client MUST have the class (java .class file) in its classpath in order to work with the class loaded by another class loader. Much like how in an EJB container, the web server calling to EJB MUST contain the Home and Remote interface .class files in its classpath, the same thing needs to be done here. For us, this means if a plugin depends on 5 others, it must contain ALL of the .class files of those plugins it depends on, so that the classloader instance that loads the plugin, can also see those classes and work with them.
Have you got any other ideas? I really dislike that this has to be done in this manner. It seems to me that the JVM should be able to allow various class loaders to work with one another in such a way that if a client loaded by one classloader has an import statement in it to use a class, the JVM should be able to fetch the .class out of the other classloader and share it, or something!
This seems to me that there really is no way to actually properly unload and then reload a class so that the JVM will discard and free up the previous class completely, while using the new class.
I would be interested in discussing this topic further. Maybe some others will join in and help out on this topic. I am surprised there isn't a top-level forum topic about things like class loaders, JVM, etc. I wish there was a way to add one!

Increasing number of class loaded. Class leak?

Hi there,
I am concern about the high number of classes loaded by one application. Using JConsole I see linear time raising in the number of classes loaded, after monitoring that for about 24 hours the number of loaded classes continues increasing (more than 100.000), while the number of unloaded classes is less than 0.5%. So far no memory leak was observed after 24 hours.
I guess there is a logical leak in the application but I don't understand why this has no effect on the memory usage.
- Do you know about the possible reasons / side effects of this ugly class leak behavior?
- I've tried to find out more info about the class loading, but it seems to be a kind of tricky to self manage the loading/unloading process.
I'd really appreciate any information/documentation/experiences.
Thanks in advance.

What makes you think there is a 'logical leak'? I'm not sure about it, but I guess something is not working fine, as the classes remain loaded and they are not unloaded. So, a logical leak preventing the classes to be unloaded is not hard to believe. Maybe (and hopefully) I am wrong
The number of loaded classes? How many classes do you expect to be loaded vs the number of those that are actually loaded? I don't expect any specific number, what I expect is that the number of loaded classes does not increase linearly with the time. I mean, I expect a similar graph as the memory usage :)
Probably I am wrong but for me it does not seem normal that the classes are never unloaded ???

Is a way to get some classes loaded?

I run into a problem today. After the main class is up, a "java.lang.NoClassDefFoundError" exception is thrown while running. The class is located in the same directory as the main class.
After I turn on the verbose option, I find the class is not loaded at the point when the main class is up. Although it is loaded after the exception occurs, the exception still occurs.
I guess for the limited memory reason not all classes are loaded. Is any way I can get some classes loaded first?
Thanks for your input.
v.

This will not help you current problem, which sounds like either a class path problem, but
Is any way I can get some classes loaded first?To get a class to be loaded by the JVM, you can use Class.forName("class name"). To force it to load early in the application life (not first, as the main + Java classes will come before it) use the static initalizer, i.e.class Main {
static {
Class.forName("Jeff");
}Your second, unloading class, is it packaged correctly? And has it be compiled?

Performance issues with class loader on Windows server

We are observing some performance issues in our application. We are Using weblogic 11g with Java6 on a windows 2003 server
The thread dumps indicate many threads are waiting in queue for the native file methods:
"[ACTIVE] ExecuteThread: '106' for queue: 'weblogic.kernel.Default (self-tuning)'" RUNNABLE
     java.io.WinNTFileSystem.getBooleanAttributes(Native Method)
     java.io.File.exists(Unknown Source)
     weblogic.utils.classloaders.ClasspathClassFinder.getFileSource(ClasspathClassFinder.java:398)
     weblogic.utils.classloaders.ClasspathClassFinder.getSourcesInternal(ClasspathClassFinder.java:347)
     weblogic.utils.classloaders.ClasspathClassFinder.getSource(ClasspathClassFinder.java:316)
     weblogic.application.io.ManifestFinder.getSource(ManifestFinder.java:75)
     weblogic.utils.classloaders.MultiClassFinder.getSource(MultiClassFinder.java:67)
     weblogic.application.utils.CompositeWebAppFinder.getSource(CompositeWebAppFinder.java:71)
     weblogic.utils.classloaders.MultiClassFinder.getSource(MultiClassFinder.java:67)
     weblogic.utils.classloaders.MultiClassFinder.getSource(MultiClassFinder.java:67)
     weblogic.utils.classloaders.CodeGenClassFinder.getSource(CodeGenClassFinder.java:33)
     weblogic.utils.classloaders.GenericClassLoader.findResource(GenericClassLoader.java:210)
     weblogic.utils.classloaders.GenericClassLoader.getResourceInternal(GenericClassLoader.java:160)
     weblogic.utils.classloaders.GenericClassLoader.getResource(GenericClassLoader.java:182)
     java.lang.ClassLoader.getResourceAsStream(Unknown Source)
     javax.xml.parsers.SecuritySupport$4.run(Unknown Source)
     java.security.AccessController.doPrivileged(Native Method)
     javax.xml.parsers.SecuritySupport.getResourceAsStream(Unknown Source)
     javax.xml.parsers.FactoryFinder.findJarServiceProvider(Unknown Source)
     javax.xml.parsers.FactoryFinder.find(Unknown Source)
     javax.xml.parsers.DocumentBuilderFactory.newInstance(Unknown Source)
     org.ajax4jsf.context.ResponseWriterContentHandler.<init>(ResponseWriterContentHandler.java:48)
     org.ajax4jsf.context.ViewResources$HeadResponseWriter.<init>(ViewResources.java:259)
     org.ajax4jsf.context.ViewResources.processHeadResources(ViewResources.java:445)
     org.ajax4jsf.application.AjaxViewHandler.renderView(AjaxViewHandler.java:193)
     org.apache.myfaces.lifecycle.RenderResponseExecutor.execute(RenderResponseExecutor.java:41)
     org.apache.myfaces.lifecycle.LifecycleImpl.render(LifecycleImpl.java:140)
On googling this seems to be an issue with java file handling on windows servers and I couldn't find a solution yet. Any recommendation or pointer is appreciated

Hi shubhu,
I just analyzed your partial Thread Dump data, the problem is that the ajax4jsf framework ResponseWriterContentHandler triggers internally a new instance of the DocumentBuilderFactory; every time; triggering heavy IO contention because of Class loader / JAR file search operations.
Too many of these IO operations under heavy load will create excessive contention and severe performance degradation; regardless of the OS you are running your JVM on.
Please review the link below and see if this is related to your problem.. This is a known issue in JBOSS JIRA when using RichFaces / ajaxJSF.
https://issues.jboss.org/browse/JBPAPP-6166
Regards,
P-H
http://javaeesupportpatterns.blogspot.com/

Application Class Loader problem calling virtual function

Hello everyone
I have run in to very strange behavior of JVM
I have created a class loader which allows my to load classes from
jar file, regardless that URLClassLoader supplies this functionality.
I am using this class loader to load some classes and call their virtual functions. The class diagram looks like that:
public interface I {
   public void init();
public class AAA implements
   public void init(){
public class BBB extends AAA{
   public void init(){
      //here comes implementation
}Interface I and class AAA are loaded with System Class loader and Class BBB is loaded using my class loader from jar file.
ByteStreamClassLoader classLoader = new ByteStreamClassLoader ();
Class cl = classLoader. loadClass(�com.product.BBB�,true);
I myInterface = cl.newInstance();
myInterface.init();The problem is that from some unknown reason java class AAA.init() instead of BBB.init().
Can somebody help me what am I doing wrong?
Class Loader code attached below
public class ByteStreamClassLoader   extends ClassLoader {
    protected HashMap m_cache = new HashMap();
    public void clearCashe() {
      m_cache = new HashMap();
    private String definePackage(String className) {
      StringBuilder strB = new StringBuilder();
      //Class name must be removed from the URI in order to define a package
      String[] packageArray = className.split("\\.");
      for (int i = 0; i < packageArray.length - 1; i++) {
        strB.append(packageArray).append(".");
String packageName = strB.toString();
packageName = packageName.substring(0, packageName.length() - 1);
if (getPackage(packageName) == null) {
m_logger.log(Level.FINEST, "Defining package '" + packageName + "'");
definePackage(packageName, null, null, null, null, null, null, null);
return packageName;
public synchronized Class loadClass(String name, boolean resolve) throws
ClassNotFoundException {
name = name.replaceAll("/", ".").replaceAll(".class", "");
//Try to locate the Class in cashe
Class c = (Class) m_cache.get(name);
//Try to locate the Class in the System Class Loader
if (c == null) {
try {
c = ClassLoader.getSystemClassLoader().loadClass(name);
catch (Exception ex) {}
else {
m_logger.log(Level.FINEST, "Class '" + name + "' found in cache");
//Load the class from byte array
if (c == null) {
String resourceName = name;
if (!resourceName.endsWith(".class")) {
resourceName = resourceName.concat(".class");
//Retrieve class byte representation
if (resourceName.indexOf(".") != -1) {
resourceName =
resourceName.replaceAll("\\.", "/").replaceAll("/class", ".class");
//Use the ByteStreamClassLoader to load the class from byte array
byte[] classByteArray = null;
try {
classByteArray = getResourceBytes(resourceName);
catch (IOException ex1) {
throw new ClassNotFoundException(
"Could not load class data." + ex1.getMessage());
m_logger.log(
Level.FINEST, "Loading class '" +
name + "' Byte Length: " + classByteArray.length);
String p = definePackage(name);
c = defineClass(
name,
classByteArray,
0,
classByteArray.length,
ByteStreamClassLoader.class.getProtectionDomain());
m_cache.put(name, c);
if (resolve) {
resolveClass(c);
return c;

Hello everyone
I have run in to very strange behavior of JVM
I have created a class loader which allows my to load classes from
jar file, regardless that URLClassLoader supplies this functionality.
I am using this class loader to load some classes and call their virtual functions. The class diagram looks like that:
public interface I {
   public void init();
public class AAA implements
   public void init(){
public class BBB extends AAA{
   public void init(){
      //here comes implementation
}Interface I and class AAA are loaded with System Class loader and Class BBB is loaded using my class loader from jar file.
ByteStreamClassLoader classLoader = new ByteStreamClassLoader ();
Class cl = classLoader. loadClass(�com.product.BBB�,true);
I myInterface = cl.newInstance();
myInterface.init();The problem is that from some unknown reason java class AAA.init() instead of BBB.init().
Can somebody help me what am I doing wrong?
Class Loader code attached below
public class ByteStreamClassLoader   extends ClassLoader {
    protected HashMap m_cache = new HashMap();
    public void clearCashe() {
      m_cache = new HashMap();
    private String definePackage(String className) {
      StringBuilder strB = new StringBuilder();
      //Class name must be removed from the URI in order to define a package
      String[] packageArray = className.split("\\.");
      for (int i = 0; i < packageArray.length - 1; i++) {
        strB.append(packageArray).append(".");
String packageName = strB.toString();
packageName = packageName.substring(0, packageName.length() - 1);
if (getPackage(packageName) == null) {
m_logger.log(Level.FINEST, "Defining package '" + packageName + "'");
definePackage(packageName, null, null, null, null, null, null, null);
return packageName;
public synchronized Class loadClass(String name, boolean resolve) throws
ClassNotFoundException {
name = name.replaceAll("/", ".").replaceAll(".class", "");
//Try to locate the Class in cashe
Class c = (Class) m_cache.get(name);
//Try to locate the Class in the System Class Loader
if (c == null) {
try {
c = ClassLoader.getSystemClassLoader().loadClass(name);
catch (Exception ex) {}
else {
m_logger.log(Level.FINEST, "Class '" + name + "' found in cache");
//Load the class from byte array
if (c == null) {
String resourceName = name;
if (!resourceName.endsWith(".class")) {
resourceName = resourceName.concat(".class");
//Retrieve class byte representation
if (resourceName.indexOf(".") != -1) {
resourceName =
resourceName.replaceAll("\\.", "/").replaceAll("/class", ".class");
//Use the ByteStreamClassLoader to load the class from byte array
byte[] classByteArray = null;
try {
classByteArray = getResourceBytes(resourceName);
catch (IOException ex1) {
throw new ClassNotFoundException(
"Could not load class data." + ex1.getMessage());
m_logger.log(
Level.FINEST, "Loading class '" +
name + "' Byte Length: " + classByteArray.length);
String p = definePackage(name);
c = defineClass(
name,
classByteArray,
0,
classByteArray.length,
ByteStreamClassLoader.class.getProtectionDomain());
m_cache.put(name, c);
if (resolve) {
resolveClass(c);
return c;

Dynamic class loading problem using unknown JAR archive and directory names

I read the following article, which enlightened me a lot:
Ted Neward: Understanding Class.forName().
However, it took me some while to understand that my problem is the other way around:
I know the name of the class, I know the name of the method,
but my program/JVM does not know where to load the classes from.
Shortly, my problem is that the server engine that I am writing
uses two different versions of the same library.
So I am trying out the following solution:
My program is named TestClassPathMain.java
Assume the two libraries are named JAR1.jar and JAR2.jar
and the class/instance method that should
be exposed to TestClassPathMain.java by them is named
TestClass1.testMethod().
As long as I was depending on just one library,
I put JAR1.jar in the classpath before starting java,
and I was happy for a while.
At the moment I got the need to use another version of
TestClass1.testMethod() packaged in JAR2.jar,
a call would always access JAR1.jar's
TestClass1.testMethod().
I then decided to remove JAR1.jar from the classpath,
and programmatically define two separate ClassLoaders, one for use
with JAR1.jar and the other for use with JAR2.jar.
However, the problem is only partly solved.
Please refer to the enclosed code for details.
(The code in the JAR1.jar/JAR2.jar is extremely simple,
it just tells (by hardcoding) the name of the jar it is packaged in
and instantiates another class packaged in the same jar using
the "new" operator and calls a method on it. I don't enclose it.)
The TestClassPathMain.java/UC1.java/UC2.java code suite was
successfully compiled with an arbitrary of JAR1 or JAR2 in the classpath,
however removed from the classpath at runtime.
(I know that this could have been done (more elegantly...?) by producing an Interface,
but I think the main problem principle is still untouched by this potential lack of elegancy(?))
1) This problem should not be unknown to you experts out there,
how is it generally and/or most elegantly solved?
The "*** UC2: Variant 2" is the solution I would like best, had it only worked.
2) And why arent "*** UC2: Variant 2" and
"*** static UC2: Variant 2" working,
while "*** Main: Variant 2" is?
3) And a mal-apropos:
Why can't I catch the NoClassDefFoundError?
The output:
*** Main: Variant 1 JAR 1 ***:
Entering TestClass1.testMethod() packaged in JAR1.jar
About to instantiate TestClass2 with the new operator
About to call TestClass2.testMethod()
Entering TestClass2.testMethod() packaged in JAR1.jar
*** Main: Variant 1 JAR 2 ***:
Entering TestClass1.testMethod() packaged in JAR2.jar
About to instantiate TestClass2 with the new operator
About to call TestClass2.testMethod()
Entering TestClass2.testMethod() packaged in JAR2.jar
*** Main: Variant 2 JAR 1 ***:
Entering TestClass1.testMethod() packaged in JAR1.jar
About to instantiate TestClass2 with the new operator
About to call TestClass2.testMethod()
Entering TestClass2.testMethod() packaged in JAR1.jar
*** Main: Variant 2 JAR 2 ***:
Entering TestClass1.testMethod() packaged in JAR2.jar
About to instantiate TestClass2 with the new operator
About to call TestClass2.testMethod()
Entering TestClass2.testMethod() packaged in JAR2.jar
*** UC1: Variant 1 JAR 1 ***:
Entering TestClass1.testMethod() packaged in JAR1.jar
About to instantiate TestClass2 with the new operator
About to call TestClass2.testMethod()
Entering TestClass2.testMethod() packaged in JAR1.jar
*** UC1: Variant 1 JAR 2 ***:
Entering TestClass1.testMethod() packaged in JAR2.jar
About to instantiate TestClass2 with the new operator
About to call TestClass2.testMethod()
Entering TestClass2.testMethod() packaged in JAR2.jar
*** static UC2: Variant 2 JAR 1 ***:
Exception in thread "main" java.lang.NoClassDefFoundError: TestClass1
        at UC2.runFromJarVariant2_static(UC2.java:56)
        at TestClassPathMain.main(TestClassPathMain.java:52)
TestClassPathMain.java
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;
public class TestClassPathMain {
    public static void main(final String args[]) throws MalformedURLException, ClassNotFoundException, InstantiationException, SecurityException, NoSuchMethodException, IllegalArgumentException, IllegalAccessException, InvocationTargetException {
            // Commented out because I cannot catch the NoClassDefFoundError.
            // Why?
            try {
                final TestClass1 testClass1 = new TestClass1();
                System.out.println(
                    "\nThe class TestClass1 is of some unexplicable reason available." +
                    "\nFor the purpose of the test, it shouldn't have been!" +
                    "\nExiting");
                System.exit(1);
            } catch (NoClassDefFoundError e) {
                System.out.println("\nPositively confirmed that the class TestClass1 is not available:\n" + e);
                System.out.println("\n\nREADY FOR THE TEST: ...");
            // Works fine
            System.out.println("\n*** Main: Variant 1 JAR 1 ***:");
            runFromJarVariant1("file:/W:/java/eclipse/workspaces/simped_test/CP1/JAR1.jar");
            System.out.println("\n*** Main: Variant 1 JAR 2 ***:");
            runFromJarVariant1("file:/W:/java/eclipse/workspaces/simped_test/CP2/JAR2.jar");
            // Works fine
            System.out.println("\n*** Main: Variant 2 JAR 1 ***:");
            runFromJarVariant1("file:/W:/java/eclipse/workspaces/simped_test/CP1/JAR1.jar");
            System.out.println("\n*** Main: Variant 2 JAR 2 ***:");
            runFromJarVariant1("file:/W:/java/eclipse/workspaces/simped_test/CP2/JAR2.jar");
            // Works fine
            final UC1 uc1 = new UC1();
            System.out.println("\n*** UC1: Variant 1 JAR 1 ***:");
            uc1.runFromJarVariant1("file:/W:/java/eclipse/workspaces/simped_test/CP1/JAR1.jar");
            System.out.println("\n*** UC1: Variant 1 JAR 2 ***:");
            uc1.runFromJarVariant1("file:/W:/java/eclipse/workspaces/simped_test/CP2/JAR2.jar");
            // Crashes
            System.out.println("\n*** static UC2: Variant 2 JAR 1 ***:");
            UC2.runFromJarVariant2_static("file:/W:/java/eclipse/workspaces/simped_test/CP1/JAR1.jar");
            System.out.println("\n*** static UC2: Variant 2 JAR 2 ***:");
            UC2.runFromJarVariant2_static("file:/W:/java/eclipse/workspaces/simped_test/CP2/JAR2.jar");
            // Crashes
            final UC2 uc2 = new UC2();
            System.out.println("\n*** UC2: Variant 2 JAR 1 ***:");
            uc2.runFromJarVariant2("file:/W:/java/eclipse/workspaces/simped_test/CP1/JAR1.jar");
            System.out.println("\n*** UC2: Variant 2 JAR 2 ***:");
            uc2.runFromJarVariant2("file:/W:/java/eclipse/workspaces/simped_test/CP2/JAR2.jar");
    private static void runFromJarVariant1(final String jarFileURL)
        throws MalformedURLException,
               ClassNotFoundException,
               InstantiationException,
               IllegalArgumentException,
               IllegalAccessException,
               InvocationTargetException,
               SecurityException,
               NoSuchMethodException {
        final URL url = new URL(jarFileURL);
        final URLClassLoader cl =
            new URLClassLoader(new URL[]{url},
                               Thread.currentThread().getContextClassLoader());
        final Class clazz = cl.loadClass("TestClass1");
        final Object testClass1 = clazz.newInstance();
        final Method testMethod1 = clazz.getMethod("testMethod", null);
        testMethod1.invoke(testClass1, null);
    private static void runFromJarVariant2(final String jarFileURL)
        throws MalformedURLException,
               ClassNotFoundException,
               InstantiationException,
               IllegalArgumentException,
               IllegalAccessException,
               InvocationTargetException,
               SecurityException,
               NoSuchMethodException {
        final URL url = new URL(jarFileURL);
        final URLClassLoader cl =
            new URLClassLoader(new URL[]{url},
                               Thread.currentThread().getContextClassLoader());
        final Class clazz = cl.loadClass("TestClass1");
        final TestClass1 testClass1 = new TestClass1();
        testClass1.testMethod();
UC1.java
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;
public class UC1 {
    public void runFromJarVariant1(final String jarFileURL)
        throws MalformedURLException,
               ClassNotFoundException,
               InstantiationException,
               IllegalArgumentException,
               IllegalAccessException,
               InvocationTargetException,
               SecurityException,
               NoSuchMethodException {
        final URL url = new URL(jarFileURL);
        final URLClassLoader cl =
            new URLClassLoader(new URL[]{url},
                               Thread.currentThread().getContextClassLoader());
        final Class clazz = cl.loadClass("TestClass1");
        final Object testClass1 = clazz.newInstance();
        final Method testMethod1 = clazz.getMethod("testMethod", null);
        testMethod1.invoke(testClass1, null);
UC2.java
import java.lang.reflect.InvocationTargetException;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;
public class UC2 {
    public void runFromJarVariant2(final String jarFileURL)
    throws MalformedURLException,
           ClassNotFoundException,
           InstantiationException,
           IllegalArgumentException,
           IllegalAccessException,
           InvocationTargetException,
           SecurityException,
           NoSuchMethodException {
        final URL url = new URL(jarFileURL);
        final URLClassLoader cl =
            new URLClassLoader(new URL[]{url},
                               Thread.currentThread().getContextClassLoader());
        final Class clazz = cl.loadClass("TestClass1");
        final TestClass1 testClass1 = new TestClass1();
        testClass1.testMethod();
     * Identic to the "runFromJarVariant2" method,
     * except that it is static
    public static void runFromJarVariant2_static(final String jarFileURL)
    throws MalformedURLException,
           ClassNotFoundException,
           InstantiationException,
           IllegalArgumentException,
           IllegalAccessException,
           InvocationTargetException,
           SecurityException,
           NoSuchMethodException {
        final URL url = new URL(jarFileURL);
        final URLClassLoader cl =
            new URLClassLoader(new URL[]{url},
                               Thread.currentThread().getContextClassLoader());
        final Class clazz = cl.loadClass("TestClass1");
        final TestClass1 testClass1 = new TestClass1();
        testClass1.testMethod();
}

2. i need to load the class to the same JVM (i.e. to
the same environment) of the current running
aplication, so that when the loaded class is run, it
would be able to invoke methods on it!!!
ClassLoader(s) do this. Try the URLClassLoader.
(I was talking about relatively esoteric "security"
issues when I mentioned the stuff about Class objects
"scope".) You might use the URLClassLoader kind of
like this.
Pseudo-code follows:
// setup the class loader
URL[] urls = new URL[1];
urls[0] = new URL("/path/to/dynamic/classes");
URLClassLoader ucl = new URLClassLoader(urls);
// load a class & use make an object with the default constructor
Object tmp = ucl.loadClass("dynamic.class.name").newInstance();
// Cast the object to a know interface so that you can use it.
// This may be used to further determine which interface to cast
// the class to. Or it may simply be the interface to which all
// dynamic classes have to conform in your program.
InterfaceImplementedByDynamicClass loadedObj =
    (InterfaceImplementedByDynamicClass)tmp;It's really not as hard as it sounds, just write a little test of
this and you will see how it works.

Dynamic class loading in J2ME

Hi all,
Couple of questions. Is dynamic class loading using classloaders supported in any, if not all versions of J2ME? I guess I should ask first, what exactly does J2ME cover? I see KVM, but do watches and PDA's, set top boxes, refrigerators and so forth all run the same J2ME JVM? Or are their "less feature full" versions? I was hoping the J2ME spec would be the "lowest common denominator" to program for, but I thought I read somewhere that small devices like watches may even have a "smaller" J2ME JVM or something, less capable. So can I write code for J2ME and it will run on all small devices like cell phones, pda's, and so forth? Or is there another J2ME version, perhaps small than J2ME.
So, from what I have found so far, it appears dynamic class loading is done at startup from a DB (of sorts) as opposed to being able to dynamically find/load classes. If this is so, is there any way to support downloading and reloading new classes like you can with J2SE, such as the hot-swap feature of web servers? Does Class.forName() at least work in that you can "replace" a class with a new version, even if it is not able to have a separate classloader instance? My guess is that J2ME supports only a single classloader space, but I thought I read somewhere that Class.forName() is available. J2ME API shows it I believe, but I could be wrong.
Any help on this topic would be appreciated.
Thanks.

Dynamic class loading is not available in most (if not all) J2ME profiles and configurations. Class.forName() is available (at least in the MID profile), but not to be used for dynamic class loading. It can be used when using device-specific APIs where you can try to load a class containing device specific methods (for example a class that works only on certain Nokia phones, and has methods playSound() and vibrate(), which are not available in MIDP), and if you catch a ClassNotFound exception you can load a class that doesn't use the device specific APIs and contains stubs of the methods, or you can disable certain features in you application that need those features. For an example implementation you can have a look at Nokia's Block Game example (available from their developer site - http://www.forum.nokia.com/main.html).
As for your other more general questions about different JVM's and such, you should read all about the different configurations and profiles available in J2ME (plenty of information using in the J2ME link on this site).

Dynamic class loading when CODEBASE is unreachable. A bug?

Let us suppose that we have a large-scale distributed application with ca. 1000 participants communicating via RMI and utilizing dynamic class loading. As we all know, a HTTP code server must be available for this purpose in order to provide dynamically downloaded code, usually the communication proxy code of remote objects. In a real-world scenario, the HTTP server will never be 100% available, so that we will have cases that a Java process will not be able to download the necessary Java classes, causing the RMI communication to fail with a ClassNotFoundException or similar exception. In such a case, a robust application would perform some recovery activities and retry the remote call. Eventually, the HTTP server becomes available again and the distributed system recovers automatically. This seems to work fine with J2SE 1.4.2_10, but not with 1.4.2_11 and newer versions. Considering Java 5, the Update 9 exhibits the same problem.
For tracking down the problem, I've written a simple distributed test application, consisting of a client and a server. A server listens on a port, and sends a MarshalledObject to the client. The code of the MarshalledObject is annotated with the value of the "java.rmi.server.codebase" system property. The annotation contains an URL of the JAR file containing the code of the original object. The client connects to the server, reads data form the socket and unmarshalls the original object. This is basically the same procedure as when objects are accross the wire as arguments/return values/exceptions by the RMI/JRMP engine. This procedure is repeated forever in the loop. Due to the fact that the client's CLASSPATH doesn't contain the code of the original object, this code should dynamically be loaded from the HTTP server using the appropriate annotation provided by the server.
If we start the client while the HTTP server is down, the client will keep generating the ClassNotFoundException over and over again, as expected. So far, so good. If we now start the HTTP server while the client is still running, we will observe different behaviors, depending on the version of the client's JVM:
1. In J2SE 1.4.2_10, the client will download the code from the HTTP server and successfully unmarshal the original object sent by the server. ClassNotFoundExceptions will not be generated again.
2. In J2SE 1.4.2_11, 1.4.2_12 and 1.4.2_13 as well as in J2SE 5.0 Update 9, the client will continue generating ClassNotFoundExceptions. Analysis of the HTTP server's access log shows that there were no attempts to download the JAR file required for unmarshaling the object sent by the server.
It seems that in the newer JVM versions the RMI engine remembers URLs which have failed and does not attempt to access them anymore. Althogh this may have some advantages considering the overall network load, the dynamical class loading becomes practically useless in productive large distributed systems. The very first attempt to load the codebase of the communication peer must succeed, otherwise the whole process must be restarted for the communication to work, which is a very expensive (and for most customers unacceptable) operation in terms of preformance and resources usage.
Should this be seen as a bug or a feature of the JVM? What do you think?
Regards,
Miran
Here is the code to reproduce:
Server code
package server;
import java.net.*;
import java.rmi.*;
import java.io.*;
public class Server implements Serializable {
private int value = 42;
public Server() {
public String toString() {
    return "The Answer is " + value;
public static void main( String[] args ) {
    if( args.length!=1 ) {
      System.out.println( "Usage: server.Server <port>" );
      System.exit( 1 );
    try {
      MarshalledObject data = new MarshalledObject( new Server() );
      int port = Integer.parseInt( args[0] );
      ServerSocket serverSocket = new ServerSocket( port );
      System.out.println( "Accepting connections..." );
      while( true ) {
        Socket s = serverSocket.accept();
        new Thread( new SocketHandler( s, data ) ).start();
    } catch( Exception ex ) {
      ex.printStackTrace();
    System.exit( 0 );
public static class SocketHandler implements Runnable {
    private Socket s;
    private Serializable data;
    public SocketHandler( Socket s, Serializable data ) {
      this.s = s;
      this.data = data;
    public void run() {
      try {
        OutputStream os = s.getOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream( os );
        oos.writeObject( data );
        oos.close();
        os.close();
        s.close();
        System.out.println( "Serving socket succeeded" );
      } catch( Exception ex ) {
        System.out.println( "Serving socket failed" );
        ex.printStackTrace();
Client code
package client;
import java.rmi.*;
import java.net.*;
import java.io.*;
public class Client {
public static void main( String[] args ) {
    if( args.length!=1 ) {
      System.out.println( "Usage: client.Client <port>" );
      System.exit( 1 );
    try {
      if( System.getSecurityManager()==null ) {
        System.setSecurityManager( new RMISecurityManager() );
      int port = Integer.parseInt( args[0] );
      for( int i = 1; true; ++i ) {
        try {
          Socket s = new Socket( "localhost", port );
          InputStream is = s.getInputStream();
          ObjectInputStream ois = new ObjectInputStream( is );
          Object o = ois.readObject();
          ois.close();
          is.close();
          s.close();
          Object umo = ((MarshalledObject) o).get();
          System.out.println( i + ". Retreiving MarshalledObject succeeded: "
                              + umo );
        } catch( Exception ex ) {
          System.out.println( i + ". Retreiving MarshalledObject failed" );
          ex.printStackTrace();
        System.out.println( i + ". Waiting for 10 sec" );
        Thread.sleep( 10000 );
    } catch( Exception ex ) {
      ex.printStackTrace();
    System.exit( 0 );
Start command for the server
java -cp server.jar -Djava.rmi.server.codebase="http://localhost/playground/server.jar" server.Server 33933
Start command for the client
java -cp client.jar -Djava.security.policy=all.policy client.Client 33933
The policy.all file should look as follows
// All permissions
grant {
   permission java.security.AllPermission;
};The server.jar file should only contain the classes from the server package. This file should also be made accessible via HTTP (e.g. by using the Apache HTTP server).
The client.jar file should only contain the classes from the client package.

no body know about this??

Apparent EJB Class Loader Issue

I am having a problem loading narrowing an EJB. It appears to be a class loader
problem. I am getting a ClassCastException with the following message: Cannot
narrow remote object to com.dte.ejb.facade.AccessoryServiceHome.
Here is my code that looks up the EJB (I've ommitted the 'catch' clauses):
EJBHome ejbHome = (EJBHome) cache.get(homeClass);
try {
Object temp = ctx.lookup("ejb/" + homeClass.getName());
if (ejbHome == null) {
ejbHome = (EJBHome) PortableRemoteObject.narrow(temp, homeClass);
cache.put(homeClass, ejbHome);
Here is the output of some debugging information from the above method. Here I've
displayed the class.getName and the class.getClassLoader for the Class object
passed to this method and the remote object being cast by the narrow method:
homeClass : com.dte.ejb.facade.AccessoryServiceHome
homeClass : weblogic.utils.classloaders.ChangeAwareClassLoader@29164c finder:
weblogic.utils.classloaders.MultiClassFinder@300ec4
From Lookup: com.dte.ejb.facade.AccessoryServiceBean_krx5el_HomeImpl
From Lookup: weblogic.utils.classloaders.GenericClassLoader@1ea02f finder: weblogic.utils.classloaders.MultiClassFinder@6fca08
As you can see, the Class passed into this method has been loaded with the ChangeAwareClassLoader
but the HomeImpl class was loaded with the GenericClassLoader. I think that is
the problem (please correct me if I am wrong).
The application in question is an .ear with 2 .war modules and a ejb.jar file.
It was my understanding that all classes needed by any module in a .ear were all
loaded with the same class loader. Is this true? If so, then why am I having this
problem?
Thank you in advance for your help.

I just want to add few comments hoping the iPlanet engineer will be able to help me.
I mange to get one deployment of a war file with the client weblogic EJB to work; only if I add the Installation Directory path of the war file plus “web-inf/classes” to the classpath of the JVM configuration.
This tells me that the class loader looks for the JVM classpath to load the EJB home class at run time. I think; if I can make iPlanet class loader to look for the application classpath instead of the JVM my problem will go away.
Thank you in advance,
Nad

Class Loader Issues

I am dynamically creating .class files on the fly in my application. Often I need to rebuild the same class (including client classes) multiple times. The problem is that the system ClassLoader keeps the 1st .class file in memory and will not return to the disk to retrieve the new version after the class file(s) have changed.
Do I need to write a new Classloader and substitute it for the main systems class loader? Is there a better way to instantiate the class other than Class.forName( blah ) that will solve this problem?
Thanks,
-Jeff Harman

Like we told you. If the code for a class changes, Java will not automatically notice and load the new version, until you start up the JVM again. If you do not want to re-start the VM, you can create a new ClassLoader (CL), and use it to load the new code for the class.
Now, the problem is, the second CL may think it has to reload many of other classes, since it has no record of loading them itself. You will end up with duplicates of many classes.
If that doesn't suit you, there is not much alternatives.
You could rename the new version of the class, which would mean you'd have to manually track down all the old versions and upgrade them ( by using the new Ctor). You'd then have to update all the references to make them point to the new object. You can make that particular job easier by making both classes (old and new) extend a common base class, or implements the same interface, and use the interface reference (i.e program to an interface).
Another less-than-perfect possibility would be to use serialization where you serialise version-marked objects and reconstitute them with new code...
Good luck.

JVM PermGen Class Loading & Unloading Concern

Similar Messages

Maybe you are looking for