JVM Memory Model Deep Dive: Heap, Stack, GC and Thread Visibility

// io.thecodeforge.jvm.memory.MemoryLayoutDemo
// Demonstrates the five JVM memory areas and what lives where.

import java.lang.management.ManagementFactory;
import java.lang.management.MemoryMXBean;
import java.lang.management.MemoryPoolMXBean;
import java.lang.management.MemoryUsage;
import java.lang.management.ThreadMXBean;

public class MemoryLayoutDemo {

    private String applicationName = "TheCodeForge";
    private static final int MAX_CONNECTIONS = 1024;

    public static void main(String[] args) {
        MemoryMXBean memoryBean = ManagementFactory.getMemoryMXBean();

        System.out.println("=== JVM MEMORY LAYOUT ===");
        System.out.println();

        MemoryUsage heap = memoryBean.getHeapMemoryUsage();
        System.out.println("HEAP (shared across all threads):");
        System.out.printf("  Init:   %,d bytes (%.1f MB)%n", heap.getInit(), heap.getInit() / 1048576.0);
        System.out.printf("  Used:   %,d bytes (%.1f MB)%n", heap.getUsed(), heap.getUsed() / 1048576.0);
        System.out.printf("  Committed: %,d bytes (%.1f MB)%n", heap.getCommitted(), heap.getCommitted() / 1048576.0);
        System.out.printf("  Max:    %s%n", heap.getMax() == -1 ? "unlimited" : String.format("%,d bytes (%.1f MB)", heap.getMax(), heap.getMax() / 1048576.0));
        System.out.println("  Contains: all objects, arrays, string pool contents");
        System.out.println();

        MemoryUsage nonHeap = memoryBean.getNonHeapMemoryUsage();
        System.out.println("NON-HEAP (includes Metaspace):");
        System.out.printf("  Init:   %,d bytes (%.1f MB)%n", nonHeap.getInit(), nonHeap.getInit() / 1048576.0);
        System.out.printf("  Used:   %,d bytes (%.1f MB)%n", nonHeap.getUsed(), nonHeap.getUsed() / 1048576.0);
        System.out.printf("  Max:    %s%n", nonHeap.getMax() == -1 ? "unlimited (Infinity MB)" : String.format("%,d bytes (%.1f MB)", nonHeap.getMax(), nonHeap.getMax() / 1048576.0));
        System.out.println("  Contains: class metadata, method bytecode, JIT code cache");
        System.out.println();

        System.out.println("MEMORY POOLS (heap regions + non-heap regions):");
        for (MemoryPoolMXBean pool : ManagementFactory.getMemoryPoolMXBeans()) {
            MemoryUsage usage = pool.getUsage();
            System.out.printf("  %-30s  used: %6.1f MB  max: %s  type: %s%n",
                pool.getName(),
                usage.getUsed() / 1048576.0,
                usage.getMax() == -1 ? "unlimited" : String.format("%.1f MB", usage.getMax() / 1048576.0),
                pool.getType());
        }
        System.out.println();

        ThreadMXBean threadBean = ManagementFactory.getThreadMXBean();
        System.out.println("STACK (per-thread — each thread has its own):");
        System.out.printf("  Active threads: %d%n", threadBean.getThreadCount());
        System.out.printf("  Current thread stack: %s%n", Thread.currentThread().getName());
        System.out.println("  Contains: local variables, method parameters, return addresses");
        System.out.println("  Each stack frame = one method call on the call stack");
        System.out.println();

        System.out.println("PROGRAM COUNTER REGISTER (per-thread):");
        System.out.println("  Points to the next JVM instruction to execute");
        System.out.println("  For native methods: undefined (native code manages its own PC)");
        System.out.println();

        System.out.println("=== SUMMARY ===");
        System.out.println("  HEAP:       shared, objects/arrays, garbage collected");
        System.out.println("  STACK:      per-thread, local variables, auto-managed");
        System.out.println("  METASPACE:  shared, class metadata, grows until MaxMetaspaceSize");
        System.out.println("  PC REG:     per-thread, current instruction pointer");
        System.out.println("  NATIVE:     per-thread, for JNI/native method calls");
    }
}

// io.thecodeforge.jvm.memory.HeapStructureDemo
// Shows how objects move through heap generations.

import java.lang.management.ManagementFactory;
import java.lang.management.MemoryPoolMXBean;
import java.lang.management.MemoryUsage;
import java.util.ArrayList;
import java.util.List;

public class HeapStructureDemo {

    static class OrderEvent {
        private final String orderId;
        private final String customerId;
        private final double amount;
        private final long timestamp;
        private final byte[] payload;

        OrderEvent(String orderId, String customerId, double amount) {
            this.orderId = orderId;
            this.customerId = customerId;
            this.amount = amount;
            this.timestamp = System.currentTimeMillis();
            this.payload = new byte[256];
        }
    }

    public static void main(String[] args) {
        System.out.println("=== HEAP GENERATION TRACKING ===");
        System.out.println();

        printMemoryPools("BEFORE allocation");

        System.out.println("\nPhase 1: Allocating 100,000 short-lived objects...");
        for (int batch = 0; batch < 10; batch++) {
            List<OrderEvent> shortLived = new ArrayList<>();
            for (int i = 0; i < 10_000; i++) {
                shortLived.add(new OrderEvent(
                    "ORD-" + batch + "-" + i,
                    "CUST-" + (i % 1000),
                    Math.random() * 500
                ));
            }
        }
        printMemoryPools("AFTER short-lived allocation");

        System.out.println("\nRequesting GC...");
        System.gc();
        printMemoryPools("AFTER GC — Eden should be nearly empty");

        System.out.println("\nPhase 2: Allocating 50,000 long-lived objects...");
        List<OrderEvent> longLived = new ArrayList<>();
        for (int i = 0; i < 50_000; i++) {
            longLived.add(new OrderEvent(
                "LONG-" + i,
                "CUST-PERM-" + (i % 100),
                Math.random() * 1000
            ));
        }
        printMemoryPools("AFTER long-lived allocation");

        System.out.println("\nPhase 3: Multiple GCs to promote survivors to Old Gen...");
        for (int i = 0; i < 5; i++) {
            System.gc();
            System.out.println("  GC cycle " + (i + 1) + " complete");
        }
        printMemoryPools("AFTER promotion cycles — Old Gen should have grown");
    }

    static void printMemoryPools(String label) {
        System.out.println("\n  " + label + ":");
        for (MemoryPoolMXBean pool : ManagementFactory.getMemoryPoolMXBeans()) {
            if (pool.getType() == java.lang.management.MemoryType.HEAP) {
                MemoryUsage usage = pool.getUsage();
                System.out.printf("    %-30s  used: %6.1f MB  committed: %8.1f MB%n",
                    pool.getName(),
                    usage.getUsed() / 1048576.0,
                    usage.getCommitted() / 1048576.0);
            }
        }
    }
}

// io.thecodeforge.jvm.memory.GCTuningDemo
// Demonstrates GC behavior and collector selection.

import java.lang.management.GarbageCollectorMXBean;
import java.lang.management.ManagementFactory;
import java.lang.management.MemoryPoolMXBean;
import java.lang.management.MemoryUsage;
import java.util.ArrayList;
import java.util.List;

public class GCTuningDemo {

    public static void main(String[] args) {
        System.out.println("=== GC INFORMATION ===");
        System.out.println();

        System.out.println("Active Garbage Collectors:");
        for (GarbageCollectorMXBean gc : ManagementFactory.getGarbageCollectorMXBeans()) {
            System.out.printf("  Name: %-30s  Collections: %d  Time: %d ms%n",
                gc.getName(), gc.getCollectionCount(), gc.getCollectionTime());
        }
        System.out.println();

        System.out.println("=== GC SELECTION GUIDE ===");
        System.out.println();
        System.out.println("┌─────────────────────────────────────────────────────────────────┐");
        System.out.println("│  USE G1 IF:                    │  USE ZGC IF:                 │");
        System.out.println("├────────────────────────────────┼──────────────────────────────┤");
        System.out.println("│  • Heap 4-64 GB                │  • Heap > 16 GB              │");
        System.out.println("│  • Moderate latency (50-200ms) │  • Sub-millisecond pauses    │");
        System.out.println("│  • Default, no tuning needed   │  • Real-time / trading systems│");
        System.out.println("├────────────────────────────────┼──────────────────────────────┤");
        System.out.println("│  USE PARALLEL GC IF:           │  AVOID G1 IF:                │");
        System.out.println("│  • Batch jobs / ETL            │  • Ultra-low latency (<1ms)  │");
        System.out.println("│  • Max throughput needed       │  • Heap < 2 GB               │");
        System.out.println("│  • GC pauses don't matter      │  • High-throughput batch     │");
        System.out.println("└────────────────────────────────┴──────────────────────────────┘");
        System.out.println();

        System.out.println("=== RECOMMENDED GC FLAGS ===");
        System.out.println();
        System.out.println("Low-latency (web services):");
        System.out.println("  -XX:+UseG1GC -XX:MaxGCPauseMillis=50 -XX:G1HeapRegionSize=4m");
        System.out.println();
        System.out.println("Ultra-low latency (<1ms):");
        System.out.println("  -XX:+UseZGC -XX:+ZGenerational");
        System.out.println();
        System.out.println("Throughput (batch):");
        System.out.println("  -XX:+UseParallelGC -XX:ParallelGCThreads=<cores>");
        System.out.println();
        System.out.println("GC logging (ALWAYS enable):");
        System.out.println("  -Xlog:gc*:file=gc.log:time,uptime,level,tags:filecount=5,filesize=50m");

        System.out.println("\n=== ALLOCATION PRESSURE TEST ===");
        long gcCountBefore = getTotalGCCount();
        long gcTimeBefore = getTotalGCTime();

        List<byte[]> pressure = new ArrayList<>();
        for (int i = 0; i < 200; i++) {
            pressure.add(new byte[1024 * 1024]);
            if ((i + 1) % 50 == 0) {
                long gcCountNow = getTotalGCCount();
                long gcTimeNow = getTotalGCTime();
                System.out.printf("  Allocated %d MB — GC count: %d (+%d), GC time: %d ms (+%d ms)%n",
                    i + 1, gcCountNow, gcCountNow - gcCountBefore,
                    gcTimeNow, gcTimeNow - gcTimeBefore);
            }
        }

        pressure.clear();
        System.gc();

        System.out.printf("\n  Total GC events: %d%n", getTotalGCCount() - gcCountBefore);
        System.out.printf("  Total GC time: %d ms%n", getTotalGCTime() - gcTimeBefore);
    }

    static long getTotalGCCount() {
        return ManagementFactory.getGarbageCollectorMXBeans().stream()
            .mapToLong(GarbageCollectorMXBean::getCollectionCount).sum();
    }

    static long getTotalGCTime() {
        return ManagementFactory.getGarbageCollectorMXBeans().stream()
            .mapToLong(GarbageCollectorMXBean::getCollectionTime).sum();
    }
}

// io.thecodeforge.jvm.memory.HappensBeforeDemo
// Demonstrates visibility, volatile, and data races.

public class HappensBeforeDemo {

    private static boolean running = true;
    private static volatile boolean volatileRunning = true;
    private static volatile int volatileCounter = 0;

    public static void main(String[] args) throws InterruptedException {
        System.out.println("=== HAPPENS-BEFORE DEMONSTRATION ===");
        System.out.println();

        System.out.println("--- Demo 1: Non-volatile flag (NO happens-before) ---");
        Thread worker = new Thread(() -> {
            int iterations = 0;
            while (running) {
                iterations++;
            }
            System.out.println("  Worker exited after " + iterations + " iterations");
        });
        worker.start();
        Thread.sleep(100);
        running = false;
        System.out.println("  Main set running=false. Worker MAY never see it.");
        worker.join(1000);
        if (worker.isAlive()) {
            System.out.println("  ❌ Worker still running — data race! (x86 may hide this)");
            worker.interrupt();
        }
        System.out.println();

        System.out.println("--- Demo 2: Volatile flag (happens-before guaranteed) ---");
        Thread worker2 = new Thread(() -> {
            int iterations = 0;
            while (volatileRunning) {
                iterations++;
            }
            System.out.println("  Worker exited after " + iterations + " iterations");
        });
        worker2.start();
        Thread.sleep(100);
        volatileRunning = false;
        worker2.join();
        System.out.println("  ✅ Worker exited — happens-before guaranteed");
        System.out.println();

        System.out.println("--- Demo 3: Volatile does NOT provide atomicity ---");
        Thread[] incrementers = new Thread[10];
        for (int i = 0; i < 10; i++) {
            incrementers[i] = new Thread(() -> {
                for (int j = 0; j < 10000; j++) {
                    volatileCounter++;
                }
            });
        }
        for (Thread t : incrementers) t.start();
        for (Thread t : incrementers) t.join();
        System.out.printf("  10 threads * 10,000 increments = 100,000 expected%n");
        System.out.printf("  volatileCounter = %d (likely less — lost updates!)%n", volatileCounter);
        System.out.println("  Fix: Use AtomicInteger or synchronized");
        System.out.println();

        System.out.println("--- Demo 4: Double-checked locking (requires volatile) ---");
        System.out.println("  Before Java 5, double-checked locking was BROKEN.");
        System.out.println("  Java 5+ requires volatile for correctness:");
        System.out.println("    private volatile static MyClass instance;");
        System.out.println("    if (instance == null) {");
        System.out.println("        synchronized (MyClass.class) {");
        System.out.println("            if (instance == null) {");
        System.out.println("                instance = new MyClass();");
        System.out.println("            }");
        System.out.println("        }");
        System.out.println("    }");
    }
}

// io.thecodeforge.jvm.memory.ProductionMistakesDemo
// Demonstrates common production memory mistakes and fixes.

import java.lang.management.ManagementFactory;
import java.lang.management.MemoryMXBean;
import java.lang.management.MemoryUsage;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.List;

public class ProductionMistakesDemo {

    private static final ThreadLocal<List<byte[]>> leakedThreadLocal = new ThreadLocal<>();

    public static void main(String[] args) throws Exception {
        System.out.println("=== PRODUCTION JVM MEMORY MISTAKES ===");
        System.out.println();

        System.out.println("--- Mistake 1: -Xmx too large for container ---");
        MemoryMXBean bean = ManagementFactory.getMemoryMXBean();
        MemoryUsage heap = bean.getHeapMemoryUsage();
        MemoryUsage nonHeap = bean.getNonHeapMemoryUsage();
        System.out.printf("  Heap: %.1f MB, Non-heap: %.1f MB, Thread stacks: ~10 MB%n",
            heap.getCommitted() / 1048576.0, nonHeap.getUsed() / 1048576.0);
        System.out.println("  🔧 Fix: -Xmx = 75-80% of container limit");
        System.out.println();

        System.out.println("--- Mistake 2: Off-heap (direct buffer) memory ---");
        List<ByteBuffer> directBuffers = new ArrayList<>();
        for (int i = 0; i < 100; i++) {
            directBuffers.add(ByteBuffer.allocateDirect(1024 * 1024));
        }
        System.out.printf("  Allocated 100 MB direct buffers — heap unchanged at %.1f MB%n",
            bean.getHeapMemoryUsage().getUsed() / 1048576.0);
        System.out.println("  🔧 Monitor: -XX:NativeMemoryTracking=summary");
        System.out.println("  🔧 Inspect: jcmd <pid> VM.native_memory summary");
        System.out.println();

        System.out.println("--- Mistake 3: ThreadLocal leak ---");
        Thread[] pool = new Thread[3];
        for (int i = 0; i < 3; i++) {
            pool[i] = new Thread(() -> {
                leakedThreadLocal.set(new ArrayList<>(List.of(new byte[1024 * 1024])));
            });
            pool[i].start();
            pool[i].join();
        }
        System.out.println("  3 threads leaked 1 MB each → 3 MB unreachable");
        System.out.println("  🔧 Fix: try { tl.set(value); } finally { tl.remove(); }");
        System.out.println();

        System.out.println("--- Mistake 4: String.intern() on user input ---");
        System.out.println("  ❌ String userId = request.getParameter(\"id\").intern();");
        System.out.println("  🔧 Fix: Use equals(), never intern user input");
        System.out.println();

        System.out.println("=== PRODUCTION FLAGS (COPY-PASTE READY) ===");
        System.out.println();
        System.out.println("-Xms2g -Xmx2g");
        System.out.println("-XX:MaxMetaspaceSize=512m");
        System.out.println("-XX:ReservedCodeCacheSize=256m");
        System.out.println("-XX:+UseG1GC -XX:MaxGCPauseMillis=50");
        System.out.println("-XX:+DisableExplicitGC");
        System.out.println("-XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=/var/log/jvm/");
        System.out.println("-Xlog:gc*:file=gc.log:time,uptime,level,tags:filecount=5,filesize=50m");
        System.out.println("-XX:NativeMemoryTracking=summary");
        System.out.println("-XX:+FlightRecorder");
    }
}