Java Ecosystem Overview

Table of Contents

1. Introduction
2. JVM (Java Virtual Machine)
   • Architecture of the JVM
     • Class Loader
     • JVM Memory
       • Method Area
       • Heap
       • Stack Area
       • Program Counter (PC) Register
       • Native Method Stack
     • Execution Engine
       • Interpreter
       • Just-In-Time (JIT) Compiler
       • Garbage Collector
3. JRE (Java Runtime Environment)
   • Key Components of the JRE
     • Execution Tasks
     • Class Libraries
     • Java Native Interface (JNI)
     • Security Manager
4. JDK (Java Development Kit)
   • Core Features of the JDK
     • javac (Java Compiler)
     • java (Java Application Launcher)
     • jdb (Java Debugger)
     • jar (Java Archive Tool)
     • javadoc (Java Documentation Generator)
5. JVM vs JRE vs JDK: What's the Difference?
6. JDK, JRE, JVM Hierarchy

Introduction

The Java ecosystem includes all the tools, technologies, libraries, and frameworks that support the Java programming language. It covers everything needed to develop, deploy, and manage Java applications. The main components are JDK, JRE, and JVM.

JVM (Java Development Kit)

The JVM acts like a translator that allows your computer to run Java programs and other languages compiled into Java bytecode. It translates the code into something your computer's hardware can understand and execute.

Architecture of the JVM

Class Loader

1. Loading load
   Load .class files into memory. Locates, loads, and links class files (Java bytecode) for execution.

2. Linking

   • Verification: Checks the bytecode for errors
   • Preparation: Allocates memory for static variables and initializes the memory to default values.
   • Resolution: Resolves symbolic references to direct references.

3. Initialization
   Initialization is the final step where the JVM prepares a class or interface for use. This step happens after the class has been loaded (into memory) and linked.

JVM Memory

1. Method Area
   Stores class-level data like methods, variables, and runtime constants.
   

   public class Person {
       private String name;
   
       public void setName(String name) {
           this.name = name;
       }
   }
   

   The Method Area keeps the structure of the Person class, including its methods and fields, and runtime constants.

2. Heap
   Heap is where the runtime memory objects are allocated. The heap is shared among all threads and is where the garbage collection process occurs.
   

   Person p = new Person();
   

   When you create a new Person object, it is allocated on the Heap.

3. Stack Area
   Stack area stores frames, which contain local variables, operand stacks, and references to the runtime constant pool of the class being executed. Each thread has its own stack.
   

   public void someMethod() {
       int a = 10;
       int b = 20;
       int sum = a + b;
   }
   

   Each time someMethod is called, a new frame is pushed onto the Stack Area. This frame includes local variables (a, b, and sum), an operand stack for intermediate calculations, and a reference to the method’s class in the Runtime Constant Pool.

4. Program Counter (PC) Register
   PC contains the address of the current JVM instruction being executed. Each thread has its own PC register.

5. Native Method Stack
   Similar to the Java stack, but used for native methods.

Execution Engine

1. Interpreter
   Interpreter reads and executes Java bytecode line by line, converting it to machine-level instructions.

2. Just-In-Time (JIT) Compiler
   Converts bytecode into machine code at runtime to speed up performance.

3. Garbage Collector
   Manages memory by identifying and freeing up memory that is no longer in use.

JRE

JRE is a software package that provides the necessary environment to run Java applications. It is designed to execute Java bytecode on a machine, making it an essential part of the "write once, run anywhere" (WORA) principle of Java.

Key Components of the JRE

1. Execution Tasks
   The JRE facilitates the execution of Java applications by providing the JVM and the necessary libraries and resources. JRE ensures that the JVM has everything it needs to perform these tasks on any platform.

2. Class Libraries
   JRE includes a set of standard Java class libraries, which provide reusable code for performing common tasks, like data structures, I/O, networking, concurrency, and more.

3. Java Native Interface (JNI)
   JNI allows Java applications to interact with native code written in languages like C or C++. This feature is essential for integrating platform-specific features or using existing native libraries.

JDK (Java Development Kit)

JDK is a tools that enables developers to write, compile, debug, and run Java applications. It is a superset of JRE and includes additional tools for Java development.

Core Features of the JDK

• javac (Java Compiler)
  javac is use to for converting Java source code (.java files) into bytecode (.class files). This bytecode is then executed by the Java Virtual Machine (JVM).

• java (Java Application Launcher)
  java command launches a Java application. It loads the necessary class files, interprets the bytecode, and starts the application.

• jdb (Java Debugger)
  jdb is the command-line debugger for Java programs. It allows you to inspect and debug Java applications at runtime.

• jar (Java Archive Tool)
  jar tool packages multiple files into a single archive file, typically with a .jar extension. These JAR files are used to distribute Java applications and libraries.

• javadoc (Java Documentation Generator)
  javadoc generates HTML documentation from Java source code, using the special /** */ comments known as doc comments.

JVM vs JVE vs JDK, what's the difference?

Feature/Aspect	JVM	JRE	JDK
Purpose	Executes Java bytecode	Provides the environment to run Java applications	Provides tools to develop, compile, debug, and run Java applications
Includes	JVM itself, which includes class loader, bytecode verifier, and execution engine	JVM + Core libraries (like java.lang, java.util, etc.), and other runtime components	JRE + Development tools (like javac, jdb, jar, etc.), documentation
Components	- Class Loader - Bytecode Verifier - Execution Engine (Interpreter, JIT)	- JVM - Core Java libraries - Java Plug-in - Java Web Start	- JRE - Java Compiler (javac) - JAR Tool (jar) - Debugger (jdb) - Documentation Generator (javadoc) - Other development tools
Main Functionality	Executes Java bytecode, enabling platform independence	Provides the minimum requirements to run Java applications	Allows developers to write, compile, and debug Java code
Who Uses It?	End-users running Java applications	End-users running Java applications	Java developers writing and compiling Java applications
Installation Size	Smallest	Larger than JVM but smaller than JDK	Largest (includes JRE and development tools)
Developer Tools	No	No	Yes (includes compiler, debugger, profiler, etc.)
Required to Run Java Programs	Yes	Yes	No (but needed to create Java programs)
Platform Independence	Provides platform independence by abstracting the underlying hardware	Yes, because it includes the JVM	Yes, it includes everything from JRE
Examples of Usage	- Running any Java application (e.g., desktop applications, servers)	- Running Java applications in production or end-user environments	- Writing and compiling Java code - Packaging applications - Debugging
Availability	Part of JRE and JDK	Standalone or part of JDK	Standalone package

JDK, JRE, JVM hierarchy

JDK (Java Development Kit)
│
├── JRE (Java Runtime Environment)
│   │
│   ├── JVM (Java Virtual Machine)
│   │   ├── Class Loader
│   │   ├── Bytecode Verifier
│   │   ├── Execution Engine
│   │   │   ├── Interpreter
│   │   │   ├── Just-In-Time (JIT) Compiler
│   │   │   └── Garbage Collector
│   │   └── Runtime Libraries (core libraries like java.lang, java.util, etc.)
│   │
│   └── Java APIs (Core libraries and additional libraries)
│
├── Development Tools (like javac, jdb, jar, javadoc, etc.)
└── Documentation (API docs, guides)