Java on 0AndWild_log

Deep Dive into JVM (Java Virtual Machine) (2)

Fri, 23 Sep 2022 22:27:28 +0900

JVM Components

1. Class Loader

JVM’s Class Loader loads *.class files (bytecode files converted by javac) into Runtime Data Areas to run the program.

💡

Class Loader loading occurs at runtime, when a class is first accessed. This enables Lazy Loading Singleton implementation.

Class Loading is Thread-safe.

2. Execution Engine

Executes the bytecode loaded into Runtime Data Areas by the Class Loader. It converts bytecode to machine code and executes it instruction by instruction, composed of 1-byte OpCode and operands.

Key Components

Interpreter
Compiler (Just-in-Time)

3. Garbage Collector

Responsible for removing unreferenced objects in the Heap area.

Before Java, programmers managed all program memory. In Java, the JVM manages program memory through a process called garbage collection.

ℹ️

Garbage collection continuously finds and removes unused memory in Java programs.

4. Runtime Data Areas

JVM’s memory area allocated from the OS. It holds data needed to run Java applications.

Runtime Data Areas are divided into 5 areas as follows.

ℹ️

Shared Areas

Method and Heap areas are shared by all Threads

Thread-specific Areas

Stack, PC Register, Native Method areas exist per Thread

(1) Method Area

Created when the JVM starts, it stores runtime constant pools, field and method code, static variables, method bytecode, etc. for each class and interface read by the JVM.

💡

It’s a Non-Heap area stored in the Permanent area. This is a factor to consider when specifying the PermSize (Permanent Generation size) JVM option.

1-1 Type Information

Whether it’s an Interface
Type name including package name
Type access modifiers
Associated Interface list

1-2 Runtime Constant Pool

Stores all references to Type, Field, and Method
JVM finds and references memory addresses through the Runtime Constant Pool

1-3 Field Information

Field type
Field access modifiers

1-4 Method Information

Stores metadata for all Methods including Constructors
Stores Method name, parameter count and type, return type, access modifiers, bytecode, local variable section size, etc.

1-5 Class Variable

Stores variables declared with the static keyword
Actual instances of non-primitive static variables are stored in Heap memory

(2) Heap Area

Space for storing objects created with the new operator.

ℹ️

Objects become targets for GC (Garbage Collector) when no referencing variables or fields exist.

(3) Stack Area

Stored as separate Frames per Thread, with the following elements stored.

3-1 Local Variable Area

Stores temporary data occurring during Method execution, such as local variables, parameters, and method call addresses
Stored in 4-byte units: 4-byte primitives like int, float occupy 1 cell; 8-byte primitives like double occupy 2 cells
bool generally occupies 1 cell

3-2 Operand Stack

The Method’s workspace
Indicates which commands to execute with which operands

3-3 Frame Data

Includes Constant Pool Resolution, Method Return, Exception Dispatch, etc.
Also holds referenced Exception tables
When an Exception occurs, JVM references this table to determine how to handle the Exception

(4) PC Register

Created when a Thread starts, one exists per thread.

Holds the address of the currently executing portion of the Thread, recording which part should be executed with which instruction.

💡

The OS references the PC (Program Counter) Register to know which instruction the Thread should execute next during CPU scheduling.

(5) Native Method Stack

Area for executing programs written in actual executable machine code rather than bytecode generated from Java program compilation.

Space for code written in languages other than Java
Converted to bytecode and stored through the Java Native Interface
Area where the kernel grabs the stack and independently executes the program, like a general program

JVM Execution Order

Memory Allocation
- When a program runs, JVM receives memory needed to execute the program from the OS
- JVM divides this memory into multiple areas for use
Compilation
- Java Compiler (javac) compiles *.java files and converts them to *.class Java bytecode
Class Loading
- Compiled *.class files are loaded into JVM memory through the Class Loader
Bytecode Interpretation
- Loaded *.class files are interpreted into machine code through the Execution Engine
Execution and Management
- Interpreted bytecode is placed in memory areas and actually executed
- During execution, JVM performs memory management tasks such as thread synchronization and garbage collector as needed

Deep Dive into JVM (Java Virtual Machine) (1)

Thu, 22 Sep 2022 22:06:50 +0900

While studying the Java language, I became curious about the JVM. I only knew it as a virtual computer that executes the code I write, so I wanted to dig deeper into how it works and what role it plays.

What is JVM?

An abbreviation for Java Virtual Machine, it refers to a virtual computer environment for running Java.

So what role does JVM play?

Java is not OS-dependent.

To meet this condition and execute the code we write, something is needed between Java and the OS.

That’s the JVM.

Code Execution Process

Source code (raw code) *.java must be converted to machine code (010101000101…) for the CPU to recognize it.

So does *.java get directly converted to machine code and executed…?

No. The *.java file is first converted to java bytecode (*.class) so that the JVM can recognize it.

This conversion process is performed by the java compiler.

ℹ️

The java compiler is javac.exe located in the bin folder when you install JDK.

You can generate .class files using the javac command
You can execute these .class files using the java command

So now it runs on the OS..?

⚠️

No…. bytecode is not machine code, so it doesn’t run directly on the OS…!

At this point, the JVM plays the role of interpreting this bytecode so the OS can understand it.

Thanks to this role of the JVM, Java code written once can be executed regardless of the OS.

Overall Process

*.java → converted to bytecode form *.class → converted to machine code (binary code) through JIT (Just In Time) compiler

What is JIT (Just In Time) Compiler?

Also called JIT compilation or dynamic translation.

JIT was introduced to complement the shortcomings of the interpreter approach.

It translates to machine code at the actual execution time of the program.

Performance Characteristics

💡

Since machine code is stored in cache, code that has been compiled once executes quickly.

The process of JIT compiler compiling to machine code is much slower than interpreting bytecode, but once executed, it’s fast afterwards
However, for code that runs only once, it’s advantageous to interpret directly without compiling

JVM using JIT compiler checks how often a method is executed and only compiles when it exceeds a certain threshold.

What is the Interpreter Approach?

An interpreter translates source code line by line to machine code at each execution, so execution speed is slower than statically compiled languages.

Representative Interpreter Languages

Python
JavaScript
Database language SQL

Advantages and Disadvantages

Category	Description
Advantages	Simple program modification
Disadvantages	Execution speed is slower than compiled languages

💡

Compilers translate source code to create executable files, so when program modifications occur, the source code must be recompiled.

If the program is small and simple, there’s no problem, but as the program grows larger, compilation often takes hours.

However, with an interpreter, you just modify the source code and run it, so it’s widely used in programming where modifications occur frequently.