Scribd
Upload
128 views27 pages

The Java Virtual Machine: The University of North Carolina at Chapel Hill

This document summarizes a lecture on the Java Virtual Machine (JVM). It discusses the key components of the JVM architecture, including the Java programming language, JVM, and Java APIs. It explains the phases of compilation from Java code to bytecode and the role of the JVM in executing bytecode. The document outlines the shared data areas of the JVM, including the method area, heap, and thread-specific data. It also describes how the JVM uses stack frames, operand stacks, and garbage collection.

Uploaded by

michael
Copyright
© Attribution Non-Commercial (BY-NC)
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
128 views27 pages

The Java Virtual Machine: The University of North Carolina at Chapel Hill

This document summarizes a lecture on the Java Virtual Machine (JVM). It discusses the key components of the JVM architecture, including the Java programming language, JVM, and Java APIs. It explains the phases of compilation from Java code to bytecode and the role of the JVM in executing bytecode. The document outlines the shared data areas of the JVM, including the method area, heap, and thread-specific data. It also describes how the JVM uses stack frames, operand stacks, and garbage collection.

Uploaded by

michael
Copyright
© Attribution Non-Commercial (BY-NC)
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/ 27

The University of North Carolina at Chapel Hill

COMP 144 Programming Language Concepts


Spring 2003

The Java Virtual Machine


Stotts, Hernandez-Campos

The Java Virtual Machine Java Architecture


Java Programming Language Java Virtual Machine (JVM) Java API

Reference
The content of this lecture is based on Inside the Java 2 Virtual Machine by Bill Venners
Chapter 1Introduction to Java's Architecture
http://www.artima.com/insidejvm/ed2/introarchP.html

Chapter 5 The Java Virtual Machine


http://www.artima.com/insidejvm/ed2/jvmP.html

Interactive Illustrations
http://www.artima.com/insidejvm/applets/index.html

The Java Programming Environment

Phases of Compilation

The Java Platform


The byte code generated by the Java front-end is an intermediate form
Compact
Platform-independent

The Class File


Java class file contains
Byte code for data and methods (intermediate form, platform independent) (remember byte code? ) Symbolic references from one class file to another Class names in text strings Decompiling/reverse engineering quite easy Field names and descriptors (type info)

Method names and descriptors (num args, arg types)


Symbolic refs to other class methods/fields, own methods/fields
7

The Role of the Virtual Machime

Local or Remote

Class Loaders
Bootstrap (default) loader (in the JVM) User-defined (custom) loaders

Dynamic Class Loading


You don't have to know at compile-time all the classes that may ultimately take part in a running Java application. User-defined class loaders enable you to dynamically extend a Java app at run-time As it runs, your app can determine what extra classes it needs and load them

Custom loaders can download classes across a network (applets), get them out of some kind of database, or even calculate them on the fly.
10

The Execution Engine


Back-end transformation and execution
Simple JVM
byte code interpretation Method byte codes are compiled into machine code the first time they are invoked The machine code is cached for subsequent invocation It requires more memory

Just-in-time compiler

Adaptive optimization

The interpreter monitors the activity of the program, compiling the heavily used part of the program into machine code It is much faster than simple interpretation, a little more memory The memory requirement is only slightly larger due to the 20%/80% rule of program execution (In general, 20% of the code is responsible for 80% of the execution)

11

The Java Virtual Machine

12

Shared Data Areas


Each JVM has one of each:
Method area: byte code and class (static) data storage Heap: object storage

13

Thread Data Areas

Frame in Execution
14

Stack Frames

Stack frames have three parts


Local variables Operand stack Frame data

15

Stack Frame
Local Variables
class Example3a { 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; } }

16

Stack Frame
Operand Stack
Adding 2 numbers iload_0 iload_1 Iadd istore_2

Compiler can tell how many slots the op stack will need for a method

17

Stack Frame
Frame Data
The stack frame also supports
Constant pool resolution Normal method return Exception dispatch

18

Stack Frame
Frame Allocation in a Heap
class Example3c {
public static void addAndPrint() { double result = addTwoTypes(1, 88.88); System.out.println(result) ; } public static double addTwoTypes(int i, double d) { return i + d; }

}
19

Stack Frame
Native Method
A simulated stack of the target language (e.g. C) is created for JNI

20

The Heap
Class instances (objects) and arrays are stored in a single, shared heap Each Java application has its own heap
Isolation But a JVM crash will break this isolation

JVM heaps always implement garbage collection mechanisms

21

Heap
Monolithic Object Representation

22

The Heap Split Object Representation

23

The Heap
Memory/Speed Tradeoff

24

The Heap
Arrays as Objects

25

Examples
HeapOfFish
http://www.artima.com/insidejvm/applets/HeapOfFish.html Object allocation illustration

Eternal Math Example


http://www.artima.com/insidejvm/applets/EternalMath.html

JVM execution, operand stack, illustration

26

Reading Assignment
Inside the Java 2 Virtual Machine by Bill Venners
Ch 1 Ch 5 Illustrations

27

You might also like