Scribd
Upload
22 views13 pages

Lecture 2: Java Virtual Machine (JVM) : Dr. Sapna Malik Asssitant Professor, CSE Deptt.,MSIT

The JVM loads class files and stores their information in memory areas like the method area, heap, and stack. When a class is loaded, the JVM performs linking which includes verification, preparation, and resolution. Verification checks the class file is well-formed, preparation allocates memory for static variables, and resolution replaces symbolic names with references. After linking, initialization sets static variable values and initializes parent classes before the new class. The JVM then executes the code in the class files.

Uploaded by

navec
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
22 views13 pages

Lecture 2: Java Virtual Machine (JVM) : Dr. Sapna Malik Asssitant Professor, CSE Deptt.,MSIT

The JVM loads class files and stores their information in memory areas like the method area, heap, and stack. When a class is loaded, the JVM performs linking which includes verification, preparation, and resolution. Verification checks the class file is well-formed, preparation allocates memory for static variables, and resolution replaces symbolic names with references. After linking, initialization sets static variable values and initializes parent classes before the new class. The JVM then executes the code in the class files.

Uploaded by

navec
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
You are on page 1/ 13

Lecture 2: Java Virtual Machine (JVM)

Dr. Sapna Malik


Asssitant Professor,CSE Deptt.,MSIT
Introduction to the JVM
 JVM is a component of the Java system that interprets
and executes the instructions in our class files.
 The following figure shows a block diagram of the JVM
that includes its major subsystems and memory areas.

Figure 1: Memory configuration by the JVM.


Introduction to the JVM (Cont’d)

 Each instance of the JVM has one method area, one heap, and one or
more stacks - one for each thread

 When JVM loads a class file, it puts its information in the method area

 As the program runs, all objects instantiated are stored in the heap

 The stack area is used to store activation records as a program runs


Introduction to the JVM (Cont’d)

Figure 2: Content of Memory Blocks at runtime.


The Class Loader Subsystem
 The class loader performs three main functions of JVM,
namely: loading, linking and initialization
 The linking process consists of three sub-tasks, namely,
verification, preparation, and resolution

Figure 3: Class loading process.


Class Loading Process
 Loading means reading the class file for a type, parsing it to get its
information, and storing the information in the method area.

 For each type it loads, the JVM must store the following information in
the method area:
 The fully qualified name of the type
 The fully qualified name of the type's direct superclass or if the type is an
interface, a list of its direct super interfaces .
 Whether the type is a class or an interface
 The type's modifiers ( public, abstract, final, etc)
 Constant pool for the type: constants and symbolic references.
 Field info : name, type and modifiers of variables (not constants)
 Method info: name, return type, number & types of parameters, modifiers,
bytecodes, size of stack frame and exception table.
Class Loading Process (Cont’d)
 The end of the loading process is the creation of an instance of java.lang.Class
for the loaded type.
 The purpose is to give access to some of the information captured in the
method area for the type, to the programmer.
 Some of the methods of the class java.lang.Class are:

public String getName()


public Class getSupClass()
public boolean isInterface()
public Class[] getInterfaces()
public Method[] getMethods()
public Fields[] getFields()
public Constructor[] getConstructors()
 Note that for any loaded type T, only one instance of java.lang.Class is created
even if T is used several times in an application.
 To use the above methods, we need to first call the getClass() method on any
instance of T to get the reference to the Class instance for T.
Verification During Linking Process
 The next process handled by the class loader is Linking. This involves
three sub-processes: Verification, Preparation and Resolution
 Verification is the process of ensuring that binary representation of a
class is structurally correct
 The JVM has to make sure that a file it is asked to load was generated
by a valid compiler and it is well formed
 Class B may be a valid sub-class of A at the time A and B were
compiled, but class A may have been changed and re-compiled
 Example of some of the things that are checked at verification are:
 Every method is provided with a structurally correct signature
 Every instruction obeys the type discipline of the Java language
 Every branch instruction branches to the start not middle of
another instruction
Preparation

 In this phase, the JVM allocates memory for the class (i.e static)
variables and sets them to default initial values.
 Note that class variables are not initialized to their proper initial values
until the initialization phase - no java code is executed until
initialization.
 The default values for the various types are shown below:
Resolution
 Resolution is the process of replacing symbolic names for types, fields and
methods used by a loaded type with their actual references.
 Symbolic references are resolved into a direct references by searching
through the method area to locate the referenced entity.
 For the class below, at the loading phase, the class loader would have loaded
the classes: TestClassClass, String, System and Object.
public class TestClassClass{
public static void main(String[] args){
String name = new String(“Ahmed”);
Class nameClassInfo = name.getClass();
System.out.println("Parent is: “ + nameClassInfo.getSuperclass());
}
}
 The names of these classes would have been stored in the constant pool for
TestClassClass.
 In this phase, the names are replaced with their actual references.
Class Initialization
 This is the process of setting class variables to their proper initial values - initial
values desired by the programmer.
class Example1 {
static double rate = 3.5;
static int size = 3*(int)(Math.random()*5);
...
}
 Initialization of a class consists of two steps:
 Initializing its direct superclass (if any and if not already initialized)
 Executing its own initialization statements
 The above imply that, the first class that gets initialized is Object.
 Note that static final variables are not treated as class variables but as constants
and are assigned their values at compilation.
class Example2 {
static final int angle = 35;
static final int length = angle * 2;
...
}
Class Initialization (Cont’d)

 After a class is loaded, linked, and initialized, it is ready for use. Its
static fields and static methods can be used and it can be
instantiated.
 When a new class instance is created, memory is allocated for all its
instance variables in the heap.
 Memory is also allocated recursively for all the instance variables
declared in its super class and all classes up is inheritance
hierarchy.
 All instance variables in the new object and those of its superclasses
are then initialized to their default values.
 The constructor invoked in the instantiation is then processed
according to the rules shown on the next page.
 Finally, the reference to the newly created object is returned as the
result.
Thanks

You might also like