JDK vs JRE vs JVM: Differences, Architecture Diagram and How Java Code Runs

Versions. Every program on this page was compiled and run on JDK 25.0.4.1 (Temurin, LTS, build 25.0.4.1+1-LTS). Where Java 8 behaved differently the text says so. The compiler errors and console output are quoted verbatim from those runs; the “Download” links at the end of each section point to the exact .java files. The jlink size comparison and javap listings come from the same JDK.

JDK vs JRE vs JVM: the comparison table

$ ls $JAVA_HOME
NOTICE
bin
conf
include
legal
lib
man
release

$ ls $JAVA_HOME/bin
jar jarsigner java javac javadoc javap jcmd jconsole jdb jdeprscan jdeps jfr jhsdb jimage jinfo jlink jmap jmod jnativescan jpackage jps jrunscript jshell jstack jstat jstatd jwebserver keytool rmiregistry serialver

How Java code runs, from .java to native code

Stage 1: javac produces bytecode (javap shows it)

public class HelloJvm {
    private final String name;

    public HelloJvm(String name) {
        this.name = name;
    }

    public String greet() {
        return "Hello, " + name;
    }

    public static void main(String[] args) {
        System.out.println(new HelloJvm("JVM").greet());
    }
}

$ javac HelloJvm.java && javap -c -p HelloJvm
Compiled from "HelloJvm.java"
public class HelloJvm {
  private final java.lang.String name;

  public HelloJvm(java.lang.String);
    Code:
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
         4: aload_0
         5: aload_1
         6: putfield      #7                  // Field name:Ljava/lang/String;
         9: return

  public java.lang.String greet();
    Code:
         0: aload_0
         1: getfield      #7                  // Field name:Ljava/lang/String;
         4: invokedynamic #13,  0             // InvokeDynamic #0:makeConcatWithConstants:(Ljava/lang/String;)Ljava/lang/String;
         9: areturn

  public static void main(java.lang.String[]);
    Code:
         0: getstatic     #17                 // Field java/lang/System.out:Ljava/io/PrintStream;
         3: new           #8                  // class HelloJvm
         6: dup
         7: ldc           #23                 // String JVM
         9: invokespecial #25                 // Method "<init>":(Ljava/lang/String;)V
        12: invokevirtual #28                 // Method greet:()Ljava/lang/String;
        15: invokevirtual #32                 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
        18: return
}

$ javap -v HelloJvm | head -16
  Compiled from "HelloJvm.java"
public class HelloJvm
  minor version: 0
  major version: 69
  flags: (0x0021) ACC_PUBLIC, ACC_SUPER
  this_class: #8                          // HelloJvm
  super_class: #2                         // java/lang/Object
  interfaces: 0, fields: 1, methods: 3, attributes: 3
Constant pool:

Stage 2: class loaders find and load classes

public class ClassLoaderDemo {
    public static void main(String[] args) throws Exception {
        System.out.println("String       loaded by: " + String.class.getClassLoader());
        System.out.println("java.sql.Driver by:    " + java.sql.Driver.class.getClassLoader());
        System.out.println("ClassLoaderDemo by:    " + ClassLoaderDemo.class.getClassLoader());
        System.out.println("parent of app loader:  " + ClassLoaderDemo.class.getClassLoader().getParent());
        Runtime rt = Runtime.getRuntime();
        System.out.println("max heap (MB):         " + rt.maxMemory() / (1024 * 1024));
        System.out.println("processors:            " + rt.availableProcessors());
    }
}

$ javac ClassLoaderDemo.java && java ClassLoaderDemo
String       loaded by: null
java.sql.Driver by:    jdk.internal.loader.ClassLoaders$PlatformClassLoader@58644d46
ClassLoaderDemo by:    jdk.internal.loader.ClassLoaders$AppClassLoader@7c84929b
parent of app loader:  jdk.internal.loader.ClassLoaders$PlatformClassLoader@58644d46
max heap (MB):         1496
processors:            2

$ java -Xlog:class+load HelloJvm | grep -c "source:"
618

$ java -Xlog:class+load HelloJvm | grep -E "HelloJvm|java.lang.String "
[0.021s][info][class,load] java.lang.String source: shared objects file
[0.052s][info][class,load] HelloJvm source: file:/tmp/work/cls2/

Stage 3: the execution engine, interpreter and JIT

public class JitDemo {
    static int square(int x) { return x * x; }

    public static void main(String[] args) {
        System.out.println("java.version      = " + System.getProperty("java.version"));
        System.out.println("java.vm.name      = " + System.getProperty("java.vm.name"));
        System.out.println("java.class.version= " + System.getProperty("java.class.version"));
        System.out.println("Runtime.version() = " + Runtime.version());
        long sum = 0;
        for (int i = 0; i < 200_000; i++) {
            sum += square(i);
        }
        System.out.println("sum = " + sum);
    }
}

$ java JitDemo.java
java.version      = 25.0.4.1
java.vm.name      = OpenJDK 64-Bit Server VM
java.class.version= 69.0
Runtime.version() = 25.0.4.1+1-LTS
sum = 17450708985056

$ java -XX:+PrintCompilation JitDemo | grep -E "JitDemo::"
80   70       3       JitDemo::square (4 bytes)
80   71       4       JitDemo::square (4 bytes)
81   70       3       JitDemo::square (4 bytes)   made not entrant: not used
83   72 %     3       JitDemo::main @ 69 (102 bytes)

The JVM’s insides: runtime data areas

Metaspace, not PermGen. Before Java 8 class metadata lived in a fixed-size “PermGen” area that famously caused OutOfMemoryError: PermGen space. Java 8 replaced it with Metaspace in native memory, and interviewers still ask about PermGen. The honest answer for any current JDK is that PermGen no longer exists.

Why the JRE stopped shipping separately

$ jdeps --print-module-deps HelloJvm.class
java.base

$ jlink --add-modules java.base --strip-debug --no-header-files --no-man-pages --output rt

$ du -sh rt $JAVA_HOME
56M	rt
303M	/tmp/tools/jdk-25.0.4.1+1

$ rt/bin/java --list-modules
[email protected]

$ rt/bin/java -cp . HelloJvm
Hello, JVM

Download the code. HelloJvm.java · JitDemo.java · ClassLoaderDemo.java.

Run a runnable one with java File.java (JDK 11 or later; JDK 25 recommended). Files starting with Broken are meant to fail to compile.

Common interview questions

Common mistakes

• Installing a JRE to compile. javac only exists in a JDK. “javac is not recognized” almost always means a runtime-only install or a stale PATH.
• Different JDK for build and run. Compiling with a newer JDK than you run on gives UnsupportedClassVersionError. Compile with --release N for the oldest target.
• Saying Java is only interpreted, or only compiled. Both stages exist; mention bytecode and the JIT.
• Saying the JVM is platform independent. The bytecode is; the JVM is not.
• Quoting PermGen for modern JDKs. It was removed in Java 8.
• Benchmarking a cold program. The first calls run in the interpreter; measure after warm-up (or use JMH).

FAQ

Where to go next

• Top 40 Java Concurrency Interview Questions (threads, stacks and the memory model in interview form)
• Top 40 Java Collections Interview Questions and 30 Java String Programs for Interviews (what lives on the heap)
• Compact Source Files and Instance Main Methods in Java 25 (JEP 512) (a recent change to how a Java program starts)
• Java Interview Preparation Guide

• OOPs Concepts in Java
• Abstract Class vs Interface in Java
• Method Overloading vs Overriding
• static Keyword in Java
• Constructors in Java
• final vs finally vs finalize
• Access Modifiers in Java