JVM Internals & Garbage Collection

The Java Virtual Machine (JVM) is the cornerstone of Java’s platform independence. Understanding its internals is crucial for writing high-performance Java applications.

JVM Architecture

Overview

The JVM is a specification that defines how Java bytecode should be executed. Different vendors provide their own implementations (HotSpot, OpenJ9, GraalVM, etc.).

JVM Components

Class Loader Subsystem

Responsible for loading class files into the JVM:Three phases:

Loading: Reads .class files and creates binary data
Linking: Verification, preparation, and resolution
Initialization: Executes static initializers and static blocks

Class Loader Hierarchy:

Bootstrap ClassLoader (loads JDK classes)
       ↓
Extension ClassLoader (loads extension libraries)
       ↓
Application ClassLoader (loads application classes)

Runtime Data Areas

Memory areas used during program execution:

Heap
Stack
Method Area
PC Register

Shared among all threads
Stores objects and instance variables
Garbage collected
Divided into Young and Old generations

Execution Engine

Executes bytecode through:

Interpreter: Executes bytecode line by line
JIT Compiler: Compiles frequently used bytecode to native code
Garbage Collector: Manages memory automatically

Java Bytecode

Understanding Bytecode

Java bytecode is the instruction set of the JVM. Understanding bytecode helps in performance optimization and debugging.

// Source code
public class HelloWorld {
    public static void main(String[] args) {
        int x = 5;
        int y = 10;
        int sum = x + y;
        System.out.println(sum);
    }
}

Corresponding bytecode:

Code:
iconst_5       // Push constant 5
istore_1       // Store in local variable 1 (x)
bipush 10      // Push byte constant 10
istore_2       // Store in local variable 2 (y)
iload_1        // Load x
iload_2        // Load y
iadd           // Add x + y
istore_3       // Store result in variable 3 (sum)
getstatic #2   // Get System.out
iload_3       // Load sum
invokevirtual #3  // Call println
return

Common Bytecode Instructions

Stack Operations
Arithmetic
Method Invocation

iconst_<n>  : Push int constant n (-1 to 5)
iload_<n>   : Load int from local variable n
istore_<n>  : Store int to local variable n
dup         : Duplicate top stack value
pop         : Remove top stack value

iadd    : Add two integers
isub    : Subtract two integers
imul    : Multiply two integers
idiv    : Divide two integers
irem    : Remainder of division
ineg    : Negate integer

invokevirtual   : Invoke instance method
invokestatic    : Invoke static method
invokespecial   : Invoke constructor/private method
invokeinterface : Invoke interface method
invokedynamic   : Invoke dynamic method (Java 7+)

Memory Management

Heap Structure

// Eden Space + 2 Survivor Spaces (S0, S1)
// New objects are allocated in Eden
// Minor GC moves live objects to survivor spaces

// Example: Object creation
String str = new String("Hello");  // Allocated in Eden
Integer num = 100;  // May be cached (Integer pool)

Memory Configuration

Proper JVM memory configuration is critical for application performance.

# Set heap size
java -Xms512m -Xmx2g MyApp
# -Xms: Initial heap size
# -Xmx: Maximum heap size

# Set Young Generation size
java -Xmn256m MyApp

# Set Metaspace size (Java 8+)
java -XX:MetaspaceSize=128m -XX:MaxMetaspaceSize=512m MyApp

# Enable GC logging
java -Xlog:gc*:file=gc.log:time,level,tags MyApp

Garbage Collection

GC Algorithms

Serial GC
Parallel GC
CMS (Concurrent Mark Sweep)
G1 (Garbage First)
ZGC / Shenandoah

Characteristics:

Single-threaded
Stop-the-world pauses
Suitable for small heaps

java -XX:+UseSerialGC MyApp

Use Case: Single-processor machines or small applications

Characteristics:

Multiple threads for GC
Higher throughput
Longer pause times

java -XX:+UseParallelGC MyApp

Use Case: Batch processing, scientific computing

Characteristics:

Low pause times
Concurrent with application
Deprecated in Java 9, removed in Java 14

java -XX:+UseConcMarkSweepGC MyApp

Use Case: Interactive applications (legacy)

Characteristics:

Default in Java 9+
Predictable pause times
Divides heap into regions

java -XX:+UseG1GC -XX:MaxGCPauseMillis=200 MyApp

Use Case: Large heaps, balanced performance

ZGC:

Ultra-low latency (less than 10ms pauses)
Handles large heaps (TB scale)

java -XX:+UseZGC MyApp

Shenandoah:

Concurrent compacting
Low pause times

java -XX:+UseShenandoahGC MyApp

GC Process

Marking Phase

Identifies live objects by following references from GC roots:

Thread stacks
Static variables
JNI references

Deletion Phase

Removes unreferenced objects and reclaims memory

Compaction (Optional)

Moves live objects together to prevent fragmentation

Monitoring GC

import java.lang.management.*;

public class GCMonitor {
    public static void main(String[] args) {
        // Get Memory MXBean
        MemoryMXBean memoryBean = ManagementFactory.getMemoryMXBean();
        
        // Heap memory usage
        MemoryUsage heapUsage = memoryBean.getHeapMemoryUsage();
        System.out.println("Heap Memory:");
        System.out.println("  Init: " + heapUsage.getInit() / (1024 * 1024) + " MB");
        System.out.println("  Used: " + heapUsage.getUsed() / (1024 * 1024) + " MB");
        System.out.println("  Max: " + heapUsage.getMax() / (1024 * 1024) + " MB");
        
        // GC information
        for (GarbageCollectorMXBean gc : ManagementFactory.getGarbageCollectorMXBeans()) {
            System.out.println("\nGC: " + gc.getName());
            System.out.println("  Collections: " + gc.getCollectionCount());
            System.out.println("  Time: " + gc.getCollectionTime() + " ms");
        }
    }
}

Performance Tuning

JIT Compilation

The JIT compiler optimizes frequently executed code (“hot spots”) by compiling it to native machine code.

# JIT compiler options
java -XX:+TieredCompilation MyApp  # Default in Java 8+

# Print compilation
java -XX:+PrintCompilation MyApp

# Inline depth
java -XX:MaxInlineLevel=15 MyApp

# Code cache size
java -XX:ReservedCodeCacheSize=256m MyApp

Common Performance Issues

Memory Leaks

Common Causes:

Unclosed resources
Static collections
Thread locals
Event listeners not removed

Detection:

# Heap dump
jmap -dump:live,format=b,file=heap.bin <pid>

# Analyze with tools like:
# - Eclipse MAT
# - VisualVM
# - JProfiler

High GC Overhead

Symptoms:

Frequent GC cycles
Long pause times
Low throughput

Solutions:

Increase heap size
Tune GC algorithm
Reduce object creation
Use object pools for frequently created objects

Class Loading Issues

Problems:

ClassNotFoundException
NoClassDefFoundError
Class version conflicts

Debugging:

# Verbose class loading
java -verbose:class MyApp

# Custom class loader debugging
java -XX:+TraceClassLoading -XX:+TraceClassUnloading MyApp

Profiling Tools

jstat

Monitor JVM statistics

jstat -gc <pid> 1000

jmap

Memory map and heap dump

jmap -heap <pid>

jstack

Thread dump for deadlock detection

jstack <pid>

VisualVM

All-in-one profiling tool with GUI

Best Practices

Choose Right GC

G1GC for most applications
ZGC/Shenandoah for low-latency requirements
Parallel GC for batch processing

Monitor and Profile

Enable GC logging in production
Use APM tools (New Relic, Dynatrace)
Regular heap dump analysis

Optimize Memory Usage

Reuse objects when possible
Use primitive types over wrappers
Close resources properly (try-with-resources)

Set Proper Limits

Configure heap size based on workload
Set Metaspace limits
Configure GC pause time goals

Java Fundamentals

Learn Java basics

Concurrency

Master multithreading

Spring Framework

Enterprise development

Java & Spring

Databases

Algorithms & Data Structures

System Design

JVM Internals & Garbage Collection

JVM Internals & Garbage Collection

JVM Architecture

Overview

JVM Components

Java Bytecode

Understanding Bytecode

Common Bytecode Instructions

Memory Management

Heap Structure

Memory Configuration

Garbage Collection

GC Algorithms

GC Process

Monitoring GC

Performance Tuning

JIT Compilation

Common Performance Issues

Profiling Tools

jstat

jmap

jstack

VisualVM

Best Practices

Java Fundamentals

Concurrency

Spring Framework

Build docs developers (and LLMs) love

Java & Spring

Databases

Algorithms & Data Structures

System Design

​JVM Internals & Garbage Collection

​JVM Architecture

​Overview

​JVM Components

​Java Bytecode

​Understanding Bytecode

​Common Bytecode Instructions

​Memory Management

​Heap Structure

​Memory Configuration

​Garbage Collection

​GC Algorithms

​GC Process

​Monitoring GC

​Performance Tuning

​JIT Compilation

​Common Performance Issues

​Profiling Tools

jstat

jmap

jstack

VisualVM

​Best Practices

​Related Topics

Java Fundamentals

Concurrency

Spring Framework

Build docs developers (and LLMs) love

JVM Internals & Garbage Collection

JVM Architecture

Overview

JVM Components

Java Bytecode

Understanding Bytecode

Common Bytecode Instructions

Memory Management

Heap Structure

Memory Configuration

Garbage Collection

GC Algorithms

GC Process

Monitoring GC

Performance Tuning

JIT Compilation

Common Performance Issues

Profiling Tools

Best Practices

Related Topics