The document provides an overview of the Java Virtual Machine (JVM) architecture and its critical role in executing Java programs, enabling the 'write once, run anywhere' (WORA) principle. It explains the JVM's functionalities, including class loading, memory management, and exception handling, drawing analogies to everyday objects for clarity. Additionally, it details the components of the class loader subsystem, emphasizing its importance in loading necessary classes for Java applications.

1. JAVA ROADMAP
JVM Architecture – How It Works
Introduction
Java, a widely used programming language known for its versatility and
reliability, owes much of its power to the Java Virtual Machine (JVM)
Architecture. Let’s examine the JVM’s function in executing Java programs
and how it enables the concept of “Write Once, Run Anywhere” (WORA).
Definition Of JVM
The Java Virtual Machine, commonly referred to as JVM, is a virtual computer
that runs Java code. It acts as a translator between the computer’s native
language and your Java code. Consider it as a skilled interpreter who can
translate your words so that speakers of many languages understand you.
Importance Of JVM In Running Java Applications
The JVM Architecture
plays a vital role in running Java applications, offering benefits that make Java
widely applicable. Its benefits include:

2. 1. Portability
JVM’s magic lies in its ability to make Java code portable across different
systems. It’s like a universal charger that allows you to plug in your electronic
devices, such as smartphones, tablets, or laptops, regardless of the
manufacturer. The charger handles the voltage and power requirements,
making it possible to use your devices worldwide without needing different
chargers for each country.
2. Memory Management in JVM Architecture
JVM takes care of memory management, ensuring your Java application runs
smoothly. Consider a closet organizer that optimizes space utilization by
intelligently arranging clothes, shoes, and accessories. Similarly, the JVM
efficiently allocates and releases memory for objects, keeping your program’s
memory usage in check and preventing memory-related issues.
3. Exception Handling in JVM Architecture
JVM acts as a problem solver, dealing with errors that occur during program
execution. Think of it as a safety net during a trapeze performance. If a
trapeze artist loses grip and falls, the net catches them, preventing a
disastrous outcome. Similarly, JVM detects errors or exceptions in your code
and gracefully handles them, preventing your program from crashing and
helping you identify and resolve issues.
WORA And Its Relation To JVM Architecture
WORA, or “Write Once, Run Anywhere,” is a key advantage of Java, made
possible by the JVM Architecture. Imagine writing a letter in your native

3. language and being able to share it with people around the world who speak
different languages. The recipients use their respective translators to
understand your message. Similarly, the JVM serves as a translator, enabling
Java code to be written once and run on any system with a compatible JVM.
The JVM simplifies running Java programs on different systems. It’s like a
universal remote that works with any TV, saving you from having multiple
remotes for different TVs.
JVM Architecture
The JVM Architecture is like a smart assistant that helps your computer
understand and execute Java programs. Let’s explore its architecture, which
consists of three key parts:
1. Class Loader
The class loader is like a librarian that finds and organizes the Java classes
your program needs, making sure everything is ready to go.
2. Runtime Data Area
The runtime data area serves as memory storage for different program
execution components, similar to a workspace that has multiple divisions.
1. Method Area
2. Heap Area
3. Stack Area
4. PC Register
5. Native Method Stack Area
3. Execution Engine
The execution engine acts as a skilled translator, converting your Java code
into a language that your computer can understand and execute. It does this
through two methods:

4. 1. Interpreter
2. JIT Compiler
Compilation of .java files and creation of .class files
When you write Java code in a .java file, it’s in a human-readable form. The
process of transforming this code into bytecode is similar to compiling a
document into a PDF format. The Java compiler (javac) compiles the .java file
and generates bytecode instructions that can be understood by the JVM.
These bytecode instructions are stored in .class files, which contain the binary
representation of your code.
Steps involved in running .class files:
When you run a Java program, the JVM takes over the execution process.
Here are the steps involved:
1. Class Loading: The JVM’s class loader locates and loads the required
.class files into memory.
2. Bytecode Verification: The bytecode verifier ensures that the
bytecode is valid and doesn’t violate any security rules. It’s like a

5. security checkpoint👮💼 that scans your luggage at the airport to
ensure there are no prohibited items.
3. Execution: The JVM’s execution engine interprets the bytecode
instructions or dynamically compiles them into machine code using
the JIT compiler. The bytecode instructions are executed, and the
program’s logic is carried out.
4. Memory Management: The JVM manages memory allocation and
deallocation. It automatically handles memory usage, freeing up
memory occupied by objects that are no longer needed.
5. Exception Handling: The JVM detects and handles exceptions that
occur during program execution. It ensures that your program
doesn’t crash when unexpected situations arise, just like a safety net
that catches you when you stumble.
Now let’s deep dive into the working and functioning of JVM i.e. JVM
Architecture.
ClassLoader Subsystem In JVM Architecture
1. Introduction
Have you ever wondered how Java programs easily load and run many
classes? The Class Loader Subsystem, an important component of the Java
Virtual Machine (JVM), holds the key to the answer. Let’s explore the Class
Loader Subsystem’s operations, understand its function in loading classes,
and inspect its key components.
2. Understanding the ClassLoader Subsystem
Consider the Class Loader Subsystem as your trusted friend who helps in
finding and loading the classes your Java program requires. Similar to a
diligent librarian, it finds the necessary class files and brings them into
memory so they are available for use. When your program needs the right
classes, the Class Loader Subsystem ensures that they are easily available.

6. 3. Components of the ClassLoader Subsystem:
The Class Loader Subsystem consists of different components, each playing a
crucial role in the class loading process. Let’s explore them one by one:
1. Bootstrap Class Loader:
This is like the superhero of class loaders, responsible for loading the core
Java classes that are part of the Java Development Kit (JDK). It’s the first
class loader that comes into action when the JVM starts up. Just as a
superhero lays the foundation for a story, the Bootstrap Class Loader provides
the essential building blocks for your Java programs.
2. Extension Class Loader:
Imagine you have some additional modules or libraries that enhance the
functionality of your Java program. The Extension Class Loader helps in
loading these extra modules, extending the capabilities of the core Java
classes. It’s like a friendly assistant who fetches the special tools you need to
enhance your work.
3. System/Application Class Loader:
Now, think of the System/Application Class Loader as your personal courier
service. It delivers the classes specific to your application, including the ones
you’ve created, to the JVM. This class loader looks into the classpath of your
application and ensures that all your custom classes are loaded correctly.
VISIT
BLOG.GEEKSTER.IN
FOR THE REMAINING
QUESTIONS