What is Java virtual machine?

Posted 2020-11-23 zzfx

Java Virtual Machine (JVM) is a specification that provides runtime environment in which java  bytecode can be executed. As the name implies, the JVM acts as a “virtual” machine or processor. Java‘s platform independence consists mostly of its Java Virtual Machine (JVM) . JVM makes this possible because it is aware of the specific instruction lengths and other particularities of the platform. The JVM performs following operation:

1. Loads code
2. Verifies code
3. Executes code

In most cases, other programming languages, the compiler produce code for a particular Operating System but the Java compiler produce Bytecode only for a  Java Virtual Machine . When you run a Java program, it runs as a thread within the JVM process. It is the JVM‘s responsibility to load your class files, verify code, interpret them and execute them. When you issue a command like java , the JVM loads the class definition for that particular class and calls the main method of that class.

It is the JVMs responsibility that makes it possible for the same class file to run on any other  Operating Systems . The JVM takes your compiled platform-neutral byte code and interprets it to run platform-specific machine code. It can also compile it into native code with a  JIT (a  just-in-time compiler that compiles and caches your code, usually one method at a time). Thus, it is in the JVM where your code results, if needed, in native Operating System calls. Therefore, in the  JVM , your platform-neutral threading code gets turned into platform-specific threading code.

Java allocates  threads as needed for your application. The JVM manages the memory of your Java program. So, when you create an Object, or an Audio Clip, or a plain old float, Java allocates memory for both objects and primitives. Java determines when these items are no longer referenced, and, therefore, can have their memories reclaimed. The JVM, without any prompting from the user, runs the  Garbage Collector thread (when possible or required) to reclaim used, unreferenced memory. In addition to interpreting bytecodes, the JVM must supply interfaces to the various subsystems managed by the  Operating System for display, mouse, keyboard, file system and I/O ports etc.

JVM Architecture

Each Java application runs inside a runtime instance of some concrete implementation of the abstract specification of the  Java virtual machine . There are three notions of JVM: specification, implementation, and instance.

1. Specification : A document that describes what is required of JVM Implementation.
   
   
2. Implementation: Known as JRE(Java Run Time Environment.)
   
   
3. Instance: Whenever you will run a java class file an instance of JVM is created.

As shown in picture, JVM is divided into three main subsystems:

1. Class Loader Subsystem
2. Runtime Data Area
3. Execution Engine

Class Loader Subsystem

The  Java virtual machine has a flexible  Class Loader architecture that allows a Java application to load classes in custom ways. In a JVM, each and every class is loaded by some instance of a  java.lang.ClassLoader . A classloader is a special Java class file that is responsible for loading other classes onto a Java Virtual Machine. If a Java class is invoked and needs to be executed on a Java Virtual Machine, a special Java component, called a  classloader , is used to find the Java class of interest, pull that Java class off of the file system, and execute the  bytecode of that class file on the Java Virtual Machine.

Java  Class Loader Subsystem loads, links and initializes the class file when it refers to a class for the first time at runtime. It is responsible for loading class files from file system, network or any other source. There are three default class loader used in Java, Bootstrap ,  Extension and  System or Application class loader.

Boot Strap class Loader

When a JVM starts up, a special chunk of machine code runs that loads the system classloader. This machine code is known as the  Bootstrap / Primordial classloader. It is platform specific machine instructions that kick off the whole classloading process. The bootstrap classloader also takes care of loading all of the code needed to support the basic  Java Runtime Environment (JRE), including classes in the java.util and the java.lang packages .

Extension ClassLoader

The Extension class loader loads the classes from the JRE’s extension directories, such  lib/ext directories. Extension ClassLoader delegates class loading request to its parent, Bootstrap and if unsuccessful, loads class form  jre/lib/ext directory or any other directory pointed by  java.ext.dirs system property. Extension ClassLoader in JVM is implemented by  sun.misc.Launcher$ExtClassLoader .

System/Application Class Loader

System/Application  Class Loader is responsible for loading Application Level Classpath, path mentioned  Environment Variable etc.

Classloader - Linking

Linking is the process of incorporating the loaded bytecodes into the Java  Runtime System so that the loaded Type can be used by the JVM. It involves verifying and preparing that class or interface, its direct superclass, its direct  superinterfaces , and its element type (if it is an array type), if necessary.

1. Verify: Bytecode verifier will verify whether the generated bytecode is proper or not if verification fails we will get 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.

Initialization

This is the final phase of Class Loading, here all static variable will be assigned with the original values and  static block will be executed.

Runtime Data Areas

The  Java Virtual Machine (JVM) defines various run-time data areas that are used during execution of a program. Some of these data areas are created on Java Virtual Machine start-up and are destroyed only when the Java Virtual Machine exits. Other data areas are per  thread . Per-thread data areas are created when a thread is created and destroyed when the thread exits.

Method Area

It is memory which is shared among all Threads like  Heap . It is created on Java Virtual Machine startup. It contains the code actually a compiled code, methods and its data and fields. Runtime constant pool is also a part of  Method Area .

Heap Area

Heap is a  memory place where the objects and its instance variable are stored. Each time an object is created in Java it goes into the area of  memory known as heap.

Stack Area

Stack is a memory place where the methods and the  local variables are stored. Variable references (either primitive or object references) are stored in the  Stack

PC Register

 

PC Register basically is a  address of current instruction is being executed. Since each thread some sets of method which is going to be executed depends upon  PC Register. It has some value for each instruction and undefined for  native methods . It is usually for keep tracking of instructions.

Native Method Stack

Native methods are those which are written in languages other than java.  JVM implementations cannot load native methods and can‘t rely on conventional stacks . It is also associated with each thread. In short it same as stack but it is used for  native methods .

Execution Engine

This is the core of the JVM.  Execution engine can communicate with various memory areas of JVM. Each thread of a running Java application is a distinct instance of the virtual machine‘s execution engine. The byte code that is assigned to the runtime data areas in the JVM via  class loader is executed by the execution engine.

1. Interpreter 
2. JIT Compiler
3. Garbage Collector

Interpreter

Reads, interprets and executes the  bytecode instructions one by one. As it interprets and executes instructions one by one, it can quickly interpret one bytecode, but slowly executes the interpreted result. This is the disadvantage of the interpret language. The ‘language‘ called Bytecode basically runs like an  interpreter .

JIT Compiler

The  JIT compiler converts the bytecode to an intermediate-level expression, IR (Intermediate Representation), to execute  optimization , and then converts the expression to native code. The JIT compiler has been introduced to compensate for the disadvantages of the interpreter. The main purpose of JIT compiler is to improve the performance. Internally  JIT compiler maintains a separate count for every method. Whenever JVM across any method call, first that method will be  interpretednormally by the interpreter and JIT compiler increments the corresponding count variable.

Garbage Collector

Garbage collection (GC) is the process that aims to free up  occupied memory that is no longer referenced by any reachable Java object, and is an essential part of the Java virtual machine‘s (JVM‘s)  dynamic memory management system. All Java objects automatically grab the memory that they need when they are created, and when the object is no longer need, the Java  Garbage Collection process reclaim the memory. That means, the Garbage Collector tracked live objects and everything else designated garbage. More about.... Java Garbage Collection Basics

Native Method Interface

 

Native methods allow you to use code from other languages such as  C or C++ in your java code. You use them when java doesn‘t provide the functionality that you need.

Native Method Libraries

Native Method Libraries are Collection of the  Native Libraries which is required for the  Execution Engine .

 

http://net-informations.com/java/intro/jvm.htm