JVM Memory Model — OOMKilled by Non-Heap Overhead

// 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.StackVsHeapDemo
// Demonstrates stack overflow vs heap OOM.

public class StackVsHeapDemo {

    private static int recursionDepth = 0;

    // Stack overflow: recursive call without base case
    public static void recursiveMethod() {
        recursionDepth++;
        recursiveMethod();
    }

    // Heap OOM: allocate until out of memory
    public static void allocateUntilOOM() {
        java.util.List<byte[]> list = new java.util.ArrayList<>();
        try {
            while (true) {
                list.add(new byte[1024 * 1024]); // 1 MB each
            }
        } catch (OutOfMemoryError e) {
            System.out.println("Heap OOM after allocating " + list.size() + " MB");
        }
    }

    public static void main(String[] args) {
        System.out.println("=== STACK VS HEAP DEMONSTRATION ===\n");

        // Part 1: Stack overflow
        System.out.println("--- Stack overflow test ---");
        try {
            recursiveMethod();
        } catch (StackOverflowError e) {
            System.out.println("StackOverflowError after " + recursionDepth + " recursive calls");
        }
        System.out.println();

        // Part 2: Heap OOM
        System.out.println("--- Heap OOM test ---");
        allocateUntilOOM();

        System.out.println("\n=== CONCLUSION ===");
        System.out.println("Stack: small, per-thread, fast, auto-managed.");
        System.out.println("Heap: large, shared, slower, GC-managed.");
        System.out.println("Use stack for short-lived locals; heap for objects that live beyond method scope.");
    }
}

// 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) {\n            this.orderId = orderId;\n            this.customerId = customerId;\n            this.amount = amount;\n            this.timestamp = System.currentTimeMillis();\n            this.payload = new byte[256];\n        }
    }

    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(

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

public class HappensBeforeDemo {\n\n    private static boolean running = true;\n    private static volatile boolean volatileRunning = true;\n    private static volatile int volatileCounter = 0;\n\n    public static void main(String[] args) throws InterruptedException {\n        System.out.println(\"=== HAPPENS-BEFORE DEMONSTRATION ===\");\n        System.out.println();\n\n        System.out.println(\"--- Demo 1: Non-volatile flag (NO happens-before) ---\");\n        Thread worker = new Thread(() -> {\n            int iterations = 0;\n            while (running) {\n                iterations++;\n            }\n            System.out.println(\"  Worker exited after \" + iterations + \" iterations\");\n        });\n        worker.start();\n        Thread.sleep(100);\n        running = false;\n        System.out.println(\"  Main set running=false. Worker MAY never see it.\");\n        worker.join(1000);\n        if (worker.isAlive()) {\n            System.out.println(\"  ❌ Worker still running — data race! (x86 may hide this)\");\n            worker.interrupt();\n        }\n        System.out.println();\n\n        System.out.println(\"--- Demo 2: Volatile flag (happens-before guaranteed) ---\");\n        Thread worker2 = new Thread(() -> {\n            int iterations = 0;\n            while (volatileRunning) {\n                iterations++;\n            }\n            System.out.println(\"  Worker exited after \" + iterations + \" iterations\");\n        });\n        worker2.start();\n        Thread.sleep(100);\n        volatileRunning = false;\n        worker2.join();\n        System.out.println(\"  ✅ Worker exited — happens-before guaranteed\");\n        System.out.println();\n\n        System.out.println(\"--- Demo 3: Volatile does NOT provide atomicity ---\");\n        Thread[] incrementers = new Thread[10];\n        for (int i = 0; i < 10; i++) {\n            incrementers[i] = new Thread(() -> {\n                for (int j = 0; j < 10000; j++) {\n                    volatileCounter++;\n                }\n            });\n        }\n        for (Thread t : incrementers) t.start();\n        for (Thread t : incrementers) t.join();\n        System.out.printf(\"  10 threads * 10,000 increments = 100,000 expected%n\");\n        System.out.printf(\"  volatileCounter = %d (likely less — lost updates!)%n\", volatileCounter);\n        System.out.println(\"  Fix: Use AtomicInteger or synchronized\");\n        System.out.println();\n\n        System.out.println(\"--- Demo 4: Double-checked locking (requires volatile) ---\");\n        System.out.println(\"  Before Java 5, double-checked locking was BROKEN.\");\n        System.out.println(\"  Java 5+ requires volatile for correctness:\");\n        System.out.println(\"    private volatile static MyClass instance;\");\n        System.out.println(\"    if (instance == null) {\");\n        System.out.println(\"        synchronized (MyClass.class) {\");\n        System.out.println(\"            if (instance == null) {\");\n        System.out.println(\"                instance = new MyClass();\");\n        System.out.println(\"            }\");\n        System.out.println(\"        }\");\n        System.out.println(\"    }\");\n    }\n}"
      }

// 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[