What Is the JVM?

A Virtual Machine is a software implementation of a physical machine.

Java was developed with the concept of WORA (Write Once Run
Anywhere), which runs on a VM. The compiler compiles the Java file into a
Java .class file, then that .class file is input into the JVM, which loads and
executes the class file. Below is a diagram of the Architecture of the JVM.

JVM Architecture Diagram

How Does the JVM Work?

As shown in the above architecture diagram, the JVM is divided into three
main subsystems:

1. ClassLoader Subsystem
2. Runtime Data Area
3. Execution Engine

1. ClassLoader Subsystem
Java's dynamic class loading functionality is handled by the ClassLoader
subsystem. It loads, links. and initializes the class file when it refers to a
class for the first time at runtime, not compile time.

1.1 Loading
Classes will be loaded by this component. BootStrap ClassLoader, Extension
ClassLoader, and Application ClassLoader are the three ClassLoaders that
will help in achieving it.

1. BootStrap ClassLoader – Responsible for loading classes from the

bootstrap classpath, nothing but [Link]. Highest priority will be given
to this loader.
2. Extension ClassLoader – Responsible for loading classes which are
inside the ext folder (jre\lib).
3. Application ClassLoader –Responsible for loading Application Level
Classpath, path mentioned Environment Variable, etc.

The above ClassLoaders will follow Delegation Hierarchy Algorithm while

loading the class files.

1.2 Linking

1. Verify – Bytecode verifier will verify whether the generated bytecode

is proper or not if verification fails we will get the verification error.
2. Prepare – For all static variables memory will be allocated and
assigned with default values.
3. Resolve – All symbolic memory references are replaced with the
original references from Method Area.

1.3 Initialization
This is the final phase of ClassLoading; here, all static variables will be
assigned with the original values, and the static block will be executed.

2. Runtime Data Area

The Runtime Data Area is divided into five major components:

1. Method Area – All the class-level data will be stored here, including
static variables. There is only one method area per JVM, and it is a
shared resource.
2. Heap Area – All the Objects and their corresponding instance
variables and arrays will be stored here. There is also one Heap Area
per JVM. Since the Method and Heap areas share memory for multiple
threads, the data stored is not thread-safe.
3. Stack Area – For every thread, a separate runtime stack will be
created. For every method call, one entry will be made in the stack
memory which is called Stack Frame. All local variables will be
created in the stack memory. The stack area is thread-safe since it is
not a shared resource. The Stack Frame is divided into three
subentities:
1. Local Variable Array – Related to the method how many local
variables are involved and the corresponding values will be
stored here.
2. Operand stack – If any intermediate operation is required to
perform, operand stack acts as runtime workspace to perform
the operation.
3. Frame data – All symbols corresponding to the method is
stored here. In the case of any exception, the catch block
information will be maintained in the frame data.
4. PC Registers – Each thread will have separate PC Registers, to hold
the address of current executing instruction once the instruction is
executed the PC register will be updated with the next instruction.
5. Native Method stacks – Native Method Stack holds native method
information. For every thread, a separate native method stack will be
created.

3. Execution Engine
The bytecode, which is assigned to the Runtime Data Area, will be
executed by the Execution Engine. The Execution Engine reads the
bytecode and executes it piece by piece.

1. Interpreter – The interpreter interprets the bytecode faster but

executes slowly. The disadvantage of the interpreter is that when one
method is called multiple times, every time a new interpretation is
required.
2. JIT Compiler – The JIT Compiler neutralizes the disadvantage of the
interpreter. The Execution Engine will be using the help of the
interpreter in converting byte code, but when it finds repeated code it
uses the JIT compiler, which compiles the entire bytecode and
changes it to native code. This native code will be used directly for
repeated method calls, which improve the performance of the system.
1. Intermediate Code Generator – Produces intermediate code
2. Code Optimizer – Responsible for optimizing the intermediate
code generated above
3. Target Code Generator – Responsible for Generating Machine
Code or Native Code
4. Profiler – A special component, responsible for finding
hotspots, i.e. whether the method is called multiple times or
not.
3. Garbage Collector: Collects and removes unreferenced objects.
Garbage Collection can be triggered by calling [Link](), but the
execution is not guaranteed. Garbage collection of the JVM collects the
objects that are created.

Java Native Interface (JNI): JNI will be interacting with the Native Method
Libraries and provides the Native Libraries required for the Execution
Engine.
Native Method Libraries: This is a collection of the Native Libraries, which
is required for the Execution Engine.
Originally published September 2016
Java JDK, JRE and JVM
In this tutorial, you will learn about JDK, JRE, and JVM. You will also learn the
key differences between them.

What is JVM?
JVM (Java Virtual Machine) is an abstract machine that enables your
computer to run a Java program.

When you run the Java program, Java compiler first compiles your Java code
to bytecode. Then, the JVM translates bytecode into native machine code (set
of instructions that a computer's CPU executes directly).

Java is a platform-independent language. It's because when you write Java

code, it's ultimately written for JVM but not your physical machine (computer).
Since JVM executes the Java bytecode which is platform-independent, Java
is platform-independent.

Working of Java Program

If you are interested in learning about JVM Architecture, visit The JVM
Architecture Explained.

What is JRE?
JRE (Java Runtime Environment) is a software package that provides Java
class libraries, Java Virtual Machine (JVM), and other components that are
required to run Java applications.

JRE is the superset of JVM.

Java Runtime Environment

If you need to run Java programs, but not develop them, JRE is what you
need. You can download JRE from Java SE Runtime Environment 8
Downloads page.

What is JDK?
JDK (Java Development Kit) is a software development kit required to develop
applications in Java. When you download JDK, JRE is also downloaded with
it.

In addition to JRE, JDK also contains a number of development tools

(compilers, JavaDoc, Java Debugger, etc).

Java Development Kit

If you want to develop Java applications, download JDK.

Relationship between JVM, JRE, and JDK.

Relationship between JVM, JRE,

and JDK

Differences between JDK, JRE and JVM

 Difficulty Level : Easy
 Last Updated : 10 Aug, 2021
Java Development Kit (JDK) is a software development environment
used for developing Java applications and applets. It includes the Java
Runtime Environment (JRE), an interpreter/loader (Java), a compiler
(javac), an archiver (jar), a documentation generator (Javadoc), and
other tools needed in Java development.
Now we need an environment to make a run of our program.
Henceforth, JRE stands for “Java Runtime Environment” and may
also be written as “Java RTE.” The Java Runtime Environment
provides the minimum requirements for executing a Java application; it
consists of the Java Virtual Machine (JVM), core classes, and supporting
files.
Now let us discuss JVM, which stands out for java virtual machine. It is
as follows:
 A specification where the working of Java Virtual Machine is
specified. But implementation provider is independent to
choose the algorithm. Its implementation has been provided
by Sun and other companies.
 An implementation is a computer program that meets the
requirements of the JVM specification.
 Runtime Instance Whenever you write a java command on
the command prompt to run the java class, an instance of JVM
is created.
Before proceeding to the differences between JDK, JRE, and JVM, let us
discuss them in brief first and interrelate with the image below being
proposed.

Don’t get confused as we are going to discuss all of them one by one.
1. JDK (Java Development Kit) is a Kit that provides the environment
to develop and execute(run) the Java program. JDK is a kit(or
package) that includes two things
 Development Tools(to provide an environment to develop your
java programs)
 JRE (to execute your java program).

2. JRE (Java Runtime Environment) is an installation package that

provides an environment to only run(not develop) the java
program(or application)onto your machine. JRE is only used by those
who only want to run Java programs that are end-users of your system.

3. JVM (Java Virtual Machine) is a very important part of both JDK

and JRE because it is contained or inbuilt in both. Whatever Java
program you run using JRE or JDK goes into JVM and JVM is responsible
for executing the java program line by line, hence it is also known as
an interpreter.
Now let us discuss components of JRE in order to understand the
importance of it and to perceive how it actually works. For this let us
discuss components.
The components of JRE is as follows:
1. Deployment technologies, including deployment, Java Web
Start, and Java Plug-in.
2. User interface toolkits, including Abstract Window Toolkit
(AWT), Swing, Java 2D, Accessibility, Image I/O, Print Service,
Sound, drag, and drop (DnD), and input methods.
3. Integration libraries, including Interface Definition
Language (IDL), Java Database Connectivity (JDBC), Java
Naming and Directory Interface (JNDI), Remote Method
Invocation (RMI), Remote Method Invocation Over Internet
Inter-Orb Protocol (RMI-IIOP), and scripting.
4. Other base libraries, including international support,
input/output (I/O), extension mechanism, Beans, Java
Management Extensions (JMX), Java Native Interface (JNI),
Math, Networking, Override Mechanism, Security, Serialization,
and Java for XML Processing (XML JAXP).
5. Lang and util base libraries, including lang and util,
management, versioning, zip, instrument, reflection,
Collections, Concurrency Utilities, Java Archive (JAR), Logging,
Preferences API, Ref Objects, and Regular Expressions.
6. Java Virtual Machine (JVM), including Java HotSpot
Client and Server Virtual Machines.
After having an adequate understanding of the components, now let us
discuss the working of JRE. In order to understand how JRE works, let
us consider an illustration below as follows:
Illustration:
Consider a java source file saved as ‘[Link]’. The file is
compiled into a set of Byte Code that is stored in a “.class” file. Here it
will be “[Link]“.
Note: From above, media operation computing during the compile
time can be interpreted.
The following actions occur at runtime as listed below:
 Class Loader
 Byte Code Verifier
 Intrepreter
 Execute the Byte Code
 Make appropriate calls to the underlying hardware
Now let us discuss in brief how JVM do works out. It is as
follows:
JVM becomes an instance of JRE at the runtime of a Java program. It is
widely known as a runtime [Link] largely helps in the
abstraction of inner implementation from the programmers who make
use of libraries for their programs from JDK.
It is mainly responsible for three activities.
 Loading
 Linking
 Initialization
Similarly, now let us discuss the working of JRE which is as
follows:
 JVM(Java Virtual Machine) acts as a run-time engine to run Java
applications. JVM is the one that actually calls
the main method present in a java code. JVM is a part of
JRE(Java Runtime Environment).
 Java applications are called WORA (Write Once Run Anywhere).
This means a programmer can develop Java code on one
system and can expect it to run on any other Java-enabled
 system without any adjustments. This is all possible because
of JVM.
 When we compile a .java file, .class files(contains byte-code)
with the same class names present in .java file are generated
by the Java compiler. This .class file goes into various steps
when we run it. These steps together describe the whole JVM.

This article is contributed by Krishna Bhatia. If you like

GeeksforGeeks and would like to contribute, you can also write an
article using [Link] or mail your article to review-
team@[Link]. See your article appearing on the
GeeksforGeeks main page and help other Geeks.
Please write comments if you find anything incorrect, or you want to
share more information about the topic discussed above.