Java: Where is the memory allocated for the physical bytes of a class when loaded by a ClassLoader?

Question

I have constructed a tiny custom class loader in a dummy application in order to understand how dynamic class loading works. For this question, I don't need to go into details about what it does other than to mention that it instantiates two different instances of my class loader and has each one load different classes, in order that I can satisfy myself by confirming a "ClassNotFoundException" from one of the class loader instances when only the other has loaded a particular class.

However, I have a question that can be easily expressed by the following, hopefully self-explanatory line of code.

        Class clazz = myClassLoader.loadClass(theClazz);

This line of code causes my custom class loader to LOAD the class bytes into memory, and to return an instance of a Class object for that class.

My question is this: Where are the physical bytes of memory for the loaded class located (i.e., the contents of the .class file)? Are they stored inside the ClassLoader object, or are they stored inside the Class object (whereupon the ClassLoader object merely contains an internal reference to this Class object) - or somewhere else entirely?

Kaj · Answer 1 · 2011-05-20T06:55:48.333

2

From the source code for ClassLoader:

// 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();

The source code for the java classes are located in src.zip in your JDK directory.

Edit: Was that what you asked about?

edited May 20 '11 at 06:55

answered May 20 '11 at 06:50

Kaj

10,862
2
33
27

That is useful, thanks. However, it doesn't answer the question: where are the bytes corresponding to the .class file itself stored in memory? – Dan Nissenbaum Mar 01 '12 at 17:44

score 2 · Answer 2 · answered May 20 '11 at 07:21

At the lowest level, the binary representation of the class is present in various runtime areas of the virtual machine, most notably in the Method Area and in the Runtime Constant Pool. In simpler terms, the Method Area is expected to contain information about the class, including the code for methods and constructors as evidenced by the following quote from the Virtual Machine Specification:

The Java virtual machine has a method area that is shared among all Java virtual machine threads. The method area is analogous to the storage area for compiled code of a conventional language or analogous to the "text" segment in a UNIX process. It stores per-class structures such as the runtime constant pool, field and method data, and the code for methods and constructors, including the special methods (§3.9) used in class and instance initialization and interface type initialization.

Do you know whether or how, in some fashion, this block of storage is tied to specific instances of `Class`/`ClassLoader` - for example, if different class loaders load exactly the same .class file, any instances created will be considered by the JVM to be two separate, unrelated classes; presumably this means a separate copy of the code is loaded into the Method Area, but it presumably also means that either the `ClassLoader` or the `Class` instance (wherever *those* bytes are loaded into memory) contains a reference to those Method Area bytes. I would like to know which it is (of those two). — Dan Nissenbaum, May 20 '11 at 07:54

score 2 · Accepted Answer · answered May 27 '11 at 11:19

The classloader object has a Collection of all classes it has loaded.

If the same physical class is loaded by 2 different class laoders, the bytes of that class are two times in memeory. The two classes behave like different types. They are not compatible to each other! Where the bytes are stored is not really relevant, I wonder why you want to know that. If you write your own ClassLoader you can "store" them where ever you want. However at some point you will make a call like: ClassLoader.defineClass(String, byte[], int, int). Then the relevant structures in memory inside the VM are created (MethodArea, ConstantPool etc.) as mentioned in other answers.

Thank you, an excellent answer. (Apologies for the 9-month delay - but your answer sufficiently wraps this question up for me, in retrospect.) — Dan Nissenbaum, Mar 01 '12 at 17:49

score 1 · Answer 4 · answered May 20 '11 at 06:50

"This line of code causes my custom class loader to LOAD the class bytes into memory, and to return an instance of a Class object for that class"

If I understand your question correct, memory allocation for objects is done on the heap space of the java process.

score 1 · Answer 5 · answered May 20 '11 at 06:56

1

It depends on the JVM, seen for example here or here. Old versions of Mac OS used a pointer to pointer scheme, called a handle.

answered May 20 '11 at 06:56

trashgod

203,806
29
246
1,045

score 1 · Answer 6 · edited May 23 '17 at 11:55

1

The class file and its internal, JVM-specific, representation are usually stored in the Permanent Generation - at least in the Sun/Oracle incarnation of the JVM.

See What does PermGen actually stand for? for more links.

edited May 23 '17 at 11:55

Community

1
1

answered May 20 '11 at 06:59

Robert Munteanu

67,031
36
206
278

Java: Where is the memory allocated for the physical bytes of a class when loaded by a ClassLoader?

6 Answers6