Java Basics & JVM Architecture

Java Basics and JVM Architecture

Java is a high-level, class-based, object-oriented programming language designed to have as few implementation dependencies as possible. The core philosophy of Java is WORA (Write Once, Run Anywhere).

1. Why is Java Platform Independent?

1. Compilation: The Java compiler (javac) does not convert .java code into machine code. Instead, it converts it into an intermediate language called Bytecode (.class file).
2. Interpretation/Execution: This Bytecode is platform-independent. It is fed into a software machine called the JVM (Java Virtual Machine), which translates the bytecode into the specific machine code of the host computer at runtime.

• Therefore: The Bytecode is platform-independent, but the JVM is platform-dependent (you need a different JVM for Windows, Linux, and Mac).

2. JDK vs JRE vs JVM

2.1 JVM (Java Virtual Machine)

• It is an abstract machine (software program) that provides the runtime environment in which Java bytecode can be executed.
• It performs three main tasks: Loads code, Verifies code, and Executes code.

2.2 JRE (Java Runtime Environment)

• JRE = JVM + Core Libraries
• It is the physical implementation of the JVM. If you only want to run a Java program (not write one), you only need to install the JRE.
• It contains the JVM, core classes, and supporting files.

2.3 JDK (Java Development Kit)

• JDK = JRE + Development Tools
• It contains everything needed to develop Java applications. It includes the JRE, the compiler (javac), an archiver (jar), a documentation generator (javadoc), etc.

3. Detailed JVM Architecture

3.1 Class Loader Subsystem

• Loading: Reads the .class file and generates binary data.
• Linking: Verifies the bytecode (ensures it's safe) and allocates memory for static variables.
• Initialization: Assigns original values to static variables and executes static blocks.

3.2 Runtime Data Areas (Memory Areas)

1. Method Area: Stores class-level data (class names, static variables, constant pool).
2. Heap Area: Stores all Objects and their instance variables. (Garbage Collection happens here).
3. Stack Area: Stores local variables and partial results. Each thread has a separate, private JVM stack.
4. PC Register: Holds the address of the currently executing JVM instruction.
5. Native Method Stack: Holds native (C/C++) method information.

3.3 Execution Engine

• Interpreter: Reads bytecode stream and executes instructions one by one. It's fast to start but slow to execute.
• JIT (Just-In-Time) Compiler: Overcomes the slow execution of the interpreter. It compiles frequently used bytecode sequences into native machine code directly. If a method is called repeatedly, JIT provides the already compiled machine code, boosting performance significantly.
• Garbage Collector: Automatically destroys unreferenced objects in the Heap memory to free up space.