JVM 运行时数据区全景：堆、栈、方法区、程序计数器

public class StackDemo {
    public static int add(int a, int b) {
        int sum = a + b;  // a, b, sum 存在局部变量表
        return sum;       // 操作数栈: iload a → iload b → iadd → istore sum
    }
    public static void main(String[] args) {
        int result = add(3, 5); // 调用 add → 压入新栈帧；返回 → 栈帧弹出
    }
}

public class InfiniteRecursion {
    public static void stackOverflow() {
        stackOverflow(); // 每次调用都压入一个新栈帧，永不停止
    }

    public static void main(String[] args) {
        stackOverflow();
        // 抛出: java.lang.StackOverflowError
        // 默认栈大小约 512KB~1MB（-Xss 可调）
    }
}

public class HeapOOM {
    public static void main(String[] args) {
        List<byte[]> list = new ArrayList<>();
        while (true) {
            list.add(new byte[1024 * 1024]); // 每次 1MB，list 持有强引用，GC 无法回收
        } // → OOM: Java heap space（-Xms / -Xmx 控制堆大小）
    }
}

/* ═══ JDK 5/6/7：永久代 (Permanent Generation) ═══ */
// 方法区用堆内存中的一块"永久代"来实现
// 大小由 -XX:MaxPermSize 控制（默认约 64MB~82MB）
// 字符串常量池在永久代中
// 问题：大小固定，容易因加载过多类而 OOM: PermGen space

/* ═══ JDK 8+：元空间 (Metaspace) ═══ */
// 永久代被移除，方法区改用"元空间"实现
// 元空间使用本地内存 (Native Memory)，不再占用 JVM 堆内存
// 默认不设上限（受限于系统物理内存）
// 可用 -XX:MaxMetaspaceSize 设置上限
// 字符串常量池从方法区移到了堆中（其实 JDK 7 就移了）

/** 使用 CGLib 动态生成大量类，撑爆元空间 */
public class MethodAreaOOM {
    public static void main(String[] args) {
        while (true) {
            Enhancer enhancer = new Enhancer();
            enhancer.setSuperclass(OOMTarget.class);
            enhancer.setUseCache(false); // 关闭缓存，每次都生成新类
            enhancer.setCallback((MethodInterceptor) (o, m, a, p) -> p.invokeSuper(o, a));
            enhancer.create(); // → OOM: Metaspace
        }
    }
}
class OOMTarget {}

import java.nio.ByteBuffer;
public class DirectMemoryDemo {
    public static void main(String[] args) {
        ByteBuffer buffer = ByteBuffer.allocateDirect(10 * 1024 * 1024); // 分配 10MB 堆外内存
        buffer.put((byte) 1);
        buffer.flip();
        byte val = buffer.get(); // val = 1
        // 直接内存不受 GC 管理，依赖 Cleaner 机制（虚引用）回收
        // 当 DirectByteBuffer 对象被 GC 时，关联的 Cleaner 会释放堆外内存
    }
}

import java.nio.ByteBuffer;
import java.util.*;
public class DirectOOM {
    public static void main(String[] args) {
        List<ByteBuffer> buffers = new ArrayList<>();
        while (true) {
            buffers.add(ByteBuffer.allocateDirect(1024 * 1024)); // 不断分配 1MB 直接内存
        } // → OOM: Direct buffer memory (-XX:MaxDirectMemorySize 控制上限)
    }
}

public class StackErrors {
    /* 场景 1：栈深度溢出 → StackOverflowError */
    private int depth = 0;
    public void stackLeak() {
        depth++;
        stackLeak(); // 无限递归，栈帧不断压入 → StackOverflowError
    }
    /* 场景 2：栈扩展失败 → OutOfMemoryError */
    public void createThreads() {
        while (true) {
            new Thread(() -> { try { Thread.sleep(1000000); } catch (Exception e) {} }).start();
        } // 线程太多 → OOM: unable to create new native thread
    }
}