Scribd
Upload
90 views

Java's Architecture

This document discusses key aspects of Java's architecture including the Java programming language, class file format, API, and virtual machine. It describes how the virtual machine and API form a platform for Java programs and how the virtual machine loads and executes class files. The virtual machine contains a method area and heap shared by threads, and each thread has its own call stack. The stack frame contains local variables, operand stack, and frame data used during method execution.

Uploaded by

raghu8215
Copyright
© © All Rights Reserved
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
90 views

Java's Architecture

This document discusses key aspects of Java's architecture including the Java programming language, class file format, API, and virtual machine. It describes how the virtual machine and API form a platform for Java programs and how the virtual machine loads and executes class files. The virtual machine contains a method area and heap shared by threads, and each thread has its own call stack. The stack frame contains local variables, operand stack, and frame data used during method execution.

Uploaded by

raghu8215
Copyright
© © All Rights Reserved
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
You are on page 1/ 16

Features of Java

• Object-Oriented
• Robust
• Architecture Neutral and Platform Independent
• Multithreaded
• Dynamic
• Distributed
Java's Architecture
Java's architecture arises out of four distinct but
interrelated technologies:
•Java programming language
•Java class file format
•Java Application Programming Interface
•Java virtual machine
Relationship between these four parts

JVM and Java API form a "platform" for which all Java programs are
compiled.
The Java Virtual Machine
The Java virtual machine is an abstract computer
Java Runtime contains a class loader, which loads class files
from both the program and the Java API.
Only those class files from the Java API that are actually needed
by a running program are loaded into the virtual machine.
The bytecodes are executed in an execution engine.
On a Java virtual machine implemented in software, the simplest
kind of execution engine just interprets the bytecodes one at a
time.

Another kind of execution engine, one that is faster but requires


more memory, is a just-in-time compiler. In this scheme, the
bytecodes of a method are compiled to native machine code
the first time the method is invoked.

The native machine code for the method is then cached, so it can
be re-used the next time that same method is invoked.
Java Virtual Machine Architecture
Each instance of the Java virtual machine has one method area
and one heap.

shared by
all threads
running
inside JVM

When the virtual machine loads a class file, It places this type
information into the method area.

As the program runs, the virtual machine places all objects the
program instantiates onto the heap
As each new thread comes into existence, it gets its own
pc register (program counter) and Java stack.

If the thread is executing a Java method, the value of the pc


register indicates the next instruction to execute.

The state of native method invocations is stored in an


implementation-dependent way in native method stacks.
The Java stack is composed of stack frames.
A stack frame contains the state of one Java method invocation.
When a thread invokes a method, the JVM pushes a new frame
onto that thread's Java stack.
When the method completes, the JVM pops and discards the
frame for that method.
The Stack Frame
The stack frame has three parts:
local variables, operand stack, and frame data.

The sizes of the local variables and operand stack, which are
measured in words, depend upon the needs of each individual
method

When the JVM invokes a Java method, it checks the class


data to determine the number of words required by the
method in the local variables and operand stack.
It creates a stack frame of the proper size for the method and
pushes it onto the Java stack.
StackFrame : Local Variables
All values in the local variables are word-aligned

Values of type int, float and reference occupy one entry in the
local variables array.

Values of type byte, short, and char are converted to int before
being stored into the local variables.

Values of type long and double occupy two consecutive


entries in the array.
Method parameters on the local variables of a Java stack.
class Ex {
public static int runClassMethod(int i, long l, float f, double d,
Object o, byte b) { return 0; }
public int runInstanceMethod(char c, double d, short s, boolean b)
{ return 0; }
}
StackFrame: Operand Stack

Like the local variables, the operand stack is organized as an


array of words.

But unlike the local variables, which are accessed via array
indices, the operand stack is accessed by pushing and popping
values.

It converts values of type byte, short, and char to int before


pushing them onto the operand stack.
Here is how a Java virtual machine would add two local variables
that contain ints and store the int result in a third local variable:
iload_0 // push the int in local variable 0
iload_1 // push the int in local variable 1
iadd // pop two ints, add them, push result
istore_2 // pop int, store into local variable 2
Implementations of the Java Stack
public static void addAndPrint() {
double result = addTwoTypes(1, 88.88);
}
public static double addTwoTypes(int i, double d)
{ return i + d; }
The Class Loader Subsystem
Java virtual machine contains two kinds of class loaders:
Bootstrap Class loader and User-Defined Class loaders.

The bootstrap class loader is a part of the JVM implementation

User-defined class loaders are part of the running Java


application.

Classes loaded by different class loaders are placed into separate


name spaces inside the Java virtual machine

You might also like