public class StackOverflowDemo {
    private static int depth = 0;

    // 无限递归，每调用一次压入一个栈帧，直到超出 -Xss 限制
    private static void recursion() {
        depth++;
        recursion();
    }

    // 局部变量表越大，单个栈帧越大，能容纳的栈帧数越少
    private static void bigFrame() {
        long a1 = 1, a2 = 2, a3 = 3, a4 = 4, a5 = 5, a6 = 6, a7 = 7, a8 = 8;
        long b1 = 1, b2 = 2, b3 = 3, b4 = 4, b5 = 5, b6 = 6, b7 = 7, b8 = 8;
        System.out.println(a1 + a2 + a3 + a4 + a5 + a6 + a7 + a8
                + b1 + b2 + b3 + b4 + b5 + b6 + b7 + b8);
    }

    public static void main(String[] args) {
        // 建议运行时加：java -Xss256k StackOverflowDemo
        // 同样的 -Xss，栈帧越大，递归深度越浅
        new Thread(() -> {
            try {
                recursion();
            } catch (StackOverflowError e) {
                System.out.println("递归深度：" + depth + "，抛出异常：" + e.getClass().getSimpleName());
            }
        }, "stack-demo").start();
        bigFrame();
    }
}

import java.nio.ByteBuffer;

public class DirectMemoryOOM {
    // -Xmx20m -XX:MaxDirectMemorySize=64m
    public static void main(String[] args) throws Exception {
        int count = 0;
        try {
            while (true) {
                // 分配 1MB 堆外内存，不受 -Xmx 限制，但受 -XX:MaxDirectMemorySize 与物理内存限制
                ByteBuffer buffer = ByteBuffer.allocateDirect(1024 * 1024);
                count++;
                if (count % 16 == 0) {
                    System.out.println("已分配 " + count + " MB 直接内存");
                }
            }
        } catch (OutOfMemoryError e) {
            // 典型信息：java.lang.OutOfMemoryError: Direct buffer memory
            System.out.println("直接内存耗尽，已分配 " + count + " MB");
            throw e;
        }
    }
}

public class NewObjectBytecode {
    private int value = 42;

    public static void main(String[] args) {
        NewObjectBytecode obj = new NewObjectBytecode();
        obj.value = 7;
    }
}

// 依赖：org.openjdk.jol:jol-core:0.17
// import org.openjdk.jol.info.ClassLayout;
// import org.openjdk.jol.vm.VM;

public class ObjectLayoutDemo {
    static class Point {
        int x;      // 4 字节
        boolean b;  // 1 字节
        long l;     // 8 字节
        Object ref; // 4 字节（压缩指针）
    }

    public static void main(String[] args) {
        System.out.println("VM details: " + VM.current().details());
        // 未加锁时，Mark Word 后 3 bit = 001（无锁）
        System.out.println(ClassLayout.parseInstance(new Object()).toPrintable());
        // 加锁后，Mark Word 会被替换为指向 Lock Record / Monitor 的指针，标志位变为 00 或 10
        Object lock = new Object();
        synchronized (lock) {
            System.out.println(ClassLayout.parseInstance(lock).toPrintable());
        }
        System.out.println(ClassLayout.parseClass(Point.class).toPrintable());
    }
}

public class EscapeAnalysisDemo {
    static class User {
        int id;
        int age;
        User(int id, int age) { this.id = id; this.age = age; }
    }

    // 未逃逸：user 只在方法内使用，JIT 可将其标量替换为两个 int 局部变量，不产生堆分配、无需 GC
    static int sumNoEscape(int n) {
        int sum = 0;
        for (int i = 0; i < n; i++) {
            User user = new User(i, i + 1); // 一亿次 new，但堆上几乎不增长
            sum += user.id + user.age;
        }
        return sum;
    }

    // 方法逃逸：对象作为返回值被外部引用，必须真分配在堆上
    static User escapeByReturn(int id) {
        return new User(id, id + 1);
    }

    // 线程逃逸：赋值给静态字段/被其他线程可见，也属于逃逸
    static User shared;
    static void escapeByThread(User u) {
        shared = u;
    }

    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        int r = sumNoEscape(100_000_000);
        System.out.println("结果=" + r + "，耗时=" + (System.currentTimeMillis() - start) + "ms");
        // 对照实验：关闭逃逸分析后耗时与 GC 次数会显著上升
        // java -XX:-DoEscapeAnalysis -XX:-EliminateAllocations EscapeAnalysisDemo
        // 开启时可用 -XX:+PrintEliminateAllocations（debug 版 JVM）观察标量替换日志
    }
}

public class LockElisionDemo {
    // sb 不会逃逸出方法，append 内部的 synchronized 会被 JIT 消除
    static String concat(int n) {
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < n; i++) {
            sb.append(i);
        }
        return sb.toString(); // 注意：toString 让 sb 仍不逃逸（其状态被拷贝进 String）
    }

    public static void main(String[] args) throws Exception {
        long s = System.currentTimeMillis();
        concat(5_000_000);
        System.out.println("耗时=" + (System.currentTimeMillis() - s) + "ms");
        // 对照：java -XX:-EliminateLocks LockElisionDemo
    }
}

public class PrepareVsInit {
    // 准备阶段：a = 0；初始化阶段：a = 1
    static int a = 1;

    // 静态常量：编译期就折叠进常量池，准备阶段直接就是 123，不经过 <clinit>
    static final int CONST = 123;

    // 运行时才能确定的常量，仍走 <clinit>，准备阶段为 null
    static final String RUNTIME_CONST = System.currentTimeMillis() + "";

    // 经典陷阱：这里输出的是 "a=0"，因为 forward 引用在准备阶段已有零值，
    // 但静态代码块按书写顺序执行，此时 a 还没被赋 1
    static {
        System.out.println("静态代码块中 a=" + a);
        a = 2;
    }

    public static void main(String[] args) {
        System.out.println("最终 a=" + a);          // 2
        System.out.println("CONST=" + CONST);        // 常量传播，编译期已内联
        System.out.println("RUNTIME_CONST 长度=" + RUNTIME_CONST.length());
    }
}

public class ClinitDeadlock {
    static class A {
        static {
            System.out.println("A 开始初始化");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException ignored) { }
            // 触发 B 初始化，而 B 又反过来触发 A —— 同一个线程内可重入，但另一条线程交叉触发会死锁
            new B();
            System.out.println("A 初始化完成");
        }
    }

    static class B {
        static {
            System.out.println("B 开始初始化");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException ignored) { }
            new A();
            System.out.println("B 初始化完成");
        }
    }

    public static void main(String[] args) {
        // 两条线程分别先触发 A 和 B，各自持有对方的初始化锁，形成 <clinit> 死锁
        new Thread(A::new, "t1").start();
        new Thread(B::new, "t2").start();
        // 结论：<clinit> 里绝不要做耗时、阻塞或跨类循环依赖的事
    }
}

class Super {
    static int value = 100;
    static { System.out.println("Super 初始化"); }
}

class Sub extends Super {
    static { System.out.println("Sub 初始化"); }
}

interface ConstHolder {
    int N = 200;   // 接口字段默认 public static final，编译期常量
}

public class PassiveReference {
    public static void main(String[] args) throws Exception {
        // 情形一：通过子类引用父类静态字段 —— 只初始化父类，不初始化子类
        System.out.println("value = " + Sub.value);

        // 情形二：定义数组 —— 只触发元素类型加载，不初始化
        Super[] arr = new Super[10];
        System.out.println("数组长度 = " + arr.length);

        // 情形三：引用编译期常量 —— 常量已折叠进本类常量池，不触发 ConstHolder 初始化
        System.out.println("N = " + ConstHolder.N);

        // 对照：主动引用，反射强制初始化
        Class.forName("Sub");
    }
}

// 摘抄自 java.lang.ClassLoader（JDK 17，省略注释与异常细节）
protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
    synchronized (getClassLoadingLock(name)) {          // 1. 按类名加锁，保证并发下同一个类只加载一次
        Class<?> c = findLoadedClass(name);             // 2. 先查缓存：本加载器是否已加载过
        if (c == null) {
            try {
                if (parent != null) {
                    c = parent.loadClass(name, false);  // 3. 有父则递归向上委派
                } else {
                    c = findBootstrapClassOrNull(name); // 4. 无父（即 Bootstrap）则直接尝试启动类加载器
                }
            } catch (ClassNotFoundException e) {
                // 父加载器加载失败，说明它管不了这个类，由自己尝试
            }
            if (c == null) {
                c = findClass(name);                    // 5. 父都搞不定，自己动手（子类应重写 findClass）
            }
        }
        if (resolve) {
            resolveClass(c);                            // 6. 可选：立即链接
        }
        return c;
    }
}

import java.sql.Connection;
import java.sql.DriverManager;
import java.util.ServiceLoader;

public class SpiContextClassLoaderDemo {
    public static void main(String[] args) throws Exception {
        // 打印三层加载器，可以看到 Bootstrap 显示为 null
        ClassLoader cl = SpiContextClassLoaderDemo.class.getClassLoader();
        System.out.println("AppClassLoader        = " + cl);
        System.out.println("PlatformClassLoader   = " + cl.getParent());
        System.out.println("BootstrapClassLoader  = " + cl.getParent().getParent());

        // DriverManager 由 Bootstrap 加载，但通过 TCCL 去加载 classpath 下的驱动实现
        System.out.println("DriverManager 的加载器 = " + DriverManager.class.getClassLoader());
        System.out.println("当前线程 TCCL         = " + Thread.currentThread().getContextClassLoader());

        // ServiceLoader 的底层实现就是 TCCL + META-INF/services 扫描
        ServiceLoader<Runnable> loader = ServiceLoader.load(Runnable.class);
        loader.forEach(r -> System.out.println("发现服务实现：" + r.getClass().getName()));

        // JDBC 4.0+ 的 SPI 自动注册，底层就是 DriverManager 通过 TCCL 找到驱动
        Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root", "pwd");
        System.out.println("连接关闭前：" + (conn != null));
        if (conn != null) conn.close();
    }
}

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;

/**
 * 从指定目录加载 .class 文件的自定义类加载器。
 * 要点：只重写 findClass，保留双亲委派；调用 registerAsParallelCapable 以支持并行加载。
 */
public class FileClassLoader extends ClassLoader {

    static {
        // JDK 7+ ：声明本加载器是「可并行 capable」的，
        // 否则 loadClass 会对整个 ClassLoader 对象加锁，多线程加载时严重串行化
        registerAsParallelCapable();
    }

    private final Path classDir;
    private final String name;

    public FileClassLoader(String name, String classDir) {
        // 把父加载器设为「系统类加载器」，保证 java.* 等核心类仍能正确委派
        super(FileClassLoader.class.getClassLoader());
        this.name = name;
        this.classDir = Paths.get(classDir);
    }

    @Override
    protected Class<?> findClass(String className) throws ClassNotFoundException {
        byte[] bytes = loadClassBytes(className);
        if (bytes == null) {
            throw new ClassNotFoundException(className);
        }
        // defineClass 是 ClassLoader 提供的 final 方法，把字节流转为 Class 对象
        return defineClass(className, bytes, 0, bytes.length);
    }

    private byte[] loadClassBytes(String className) throws ClassNotFoundException {
        String rel = className.replace('.', '/') + ".class";
        Path file = classDir.resolve(rel);
        if (!Files.exists(file)) {
            return null;
        }
        try {
            return Files.readAllBytes(file);
        } catch (IOException e) {
            throw new ClassNotFoundException(className, e);
        }
    }

    @Override
    public String toString() {
        return name;
    }

    // 演示：同一个 class 文件被两个不同加载器加载，得到的 Class 对象互不相等
    public static void main(String[] args) throws Exception {
        String dir = args.length > 0 ? args[0] : "/tmp/hot-classes";
        String className = args.length > 1 ? args[1] : "demo.HelloService";

        FileClassLoader a = new FileClassLoader("loader-A", dir);
        FileClassLoader b = new FileClassLoader("loader-B", dir);

        Class<?> ca = a.loadClass(className);
        Class<?> cb = b.loadClass(className);

        System.out.println("ca = " + ca);
        System.out.println("cb = " + cb);
        System.out.println("同一个类吗？" + (ca == cb));                 // false —— 类的唯一性由「类名 + 加载器」共同决定
        System.out.println("ca 的加载器 = " + ca.getClassLoader());
        System.out.println("cb 的加载器 = " + cb.getClassLoader());
        System.out.println("assignable？" + ca.isAssignableFrom(cb));   // false，跨加载器无法强转

        // 但 java.lang.String 仍由 Bootstrap 加载，两个加载器委派结果一致
        System.out.println("String 类相同吗？" + (a.loadClass("java.lang.String")
                == b.loadClass("java.lang.String")));                   // true —— 这正是双亲委派的价值
    }
}

import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.HashMap;
import java.util.Map;

/**
 * 内存类加载器：只要拿到 byte[]，来源可以是网络、数据库、加密文件甚至运行时生成。
 * 每次热加载都 new 一个新的 ReloadableClassLoader，旧加载器失去引用后，
 * 其加载的类在下次 GC 时可被卸载，从而实现「不重启换代码」。
 */
public class ReloadableClassLoader extends ClassLoader {

    static { registerAsParallelCapable(); }

    private final Map<String, byte[]> bytecode = new HashMap<>();

    public ReloadableClassLoader(ClassLoader parent) {
        super(parent);
    }

    /** 预先塞入字节码，模拟从网络/数据库取到的 class 字节流 */
    public void put(String className, byte[] bytes) {
        bytecode.put(className, bytes);
    }

    public void putFromDisk(String className, String classFile) throws Exception {
        put(className, Files.readAllBytes(Paths.get(classFile)));
    }

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        byte[] bytes = bytecode.get(name);
        if (bytes == null) {
            // 兜底：交给父加载器体系处理（虽然 loadClass 已经委派过，这里保持健壮）
            throw new ClassNotFoundException(name);
        }
        // 可选：在此处做解密 / 字节码增强（ASM、Javassist 插桩通常就加在这一步）
        return defineClass(name, bytes, 0, bytes.length);
    }

    /** 模拟热加载：文件内容变化后，用新加载器重新加载，通过反射调用 */
    public static void main(String[] args) throws Exception {
        Path file = Paths.get("/tmp/hot-classes/demo/HelloService.class");
        String className = "demo.HelloService";

        ReloadableClassLoader v1 = new ReloadableClassLoader(
                ReloadableClassLoader.class.getClassLoader());
        v1.putFromDisk(className, file.toString());
        Object s1 = v1.loadClass(className).getDeclaredConstructor().newInstance();
        System.out.println("版本1 输出：" + s1.getClass().getMethod("hello").invoke(s1));

        // 假设此时磁盘上的 class 已被重新编译（改动了 hello() 的返回值）
        System.out.println("== 请重新编译 HelloService 后回车继续 ==");
        System.in.read();

        ReloadableClassLoader v2 = new ReloadableClassLoader(
                ReloadableClassLoader.class.getClassLoader());
        v2.putFromDisk(className, file.toString());
        Object s2 = v2.loadClass(className).getDeclaredConstructor().newInstance();
        System.out.println("版本2 输出：" + s2.getClass().getMethod("hello").invoke(s2));

        // 两个版本的 Class 不同，说明热替换生效；v1 失去引用后可被 GC 回收
        System.out.println("版本是否不同：" + (s1.getClass() != s2.getClass()));
        System.out.println("是否为同一个实例类型：" + s1.getClass().isAssignableFrom(s2.getClass()));
    }
}

import com.fasterxml.jackson.databind.ObjectMapper;

public class DeepChainDemo {
    // 1. 隐式递归：toString/hashCode/equals 之间互相调用，或 JSON 序列化双向引用
    static class Node {
        String name;
        Node parent;
        Node child;
        @Override
        public String toString() {
            return "Node{name=" + name + ", parent=" + parent + "}"; // parent 的 toString 又会打回来
        }
    }

    // 2. 深调用链：解析 10 万层嵌套的 JSON 数组
    static void deepJson(String json) throws Exception {
        new ObjectMapper().readTree(json);
    }

    public static void main(String[] args) throws Exception {
        Node a = new Node();
        Node b = new Node();
        a.child = b;
        b.parent = a;
        try {
            System.out.println(a);
        } catch (StackOverflowError e) {
            System.out.println("双向引用导致 toString 无限递归");
        }

        // 排查手段总结：
        // a) 异常栈里如果同一个方法出现 N 次 → 直接看那个方法的退出条件
        // b) 栈很长但每个方法只出现一次 → 调用链过深，考虑增大 -Xss 或改迭代
        // c) 用 jstack <pid> 抓取线程栈，或用 Arthas 的 thread -n 5 看最深的栈
    }
}

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

/**
 * 内存泄漏全家桶：静态集合 + ThreadLocal 未清理 + 无界缓存。
 * 复现命令：java -Xmx64m -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=./ LeakDemo
 */
public class LeakDemo {

    // 泄漏点1：静态集合持有对象，生命周期与 ClassLoader 等长，永远不会被 GC
    private static final List<byte[]> STATIC_CACHE = new ArrayList<>();

    // 泄漏点2：无界 HashMap 缓存，没有淘汰策略
    private static final Map<String, Object> UNBOUNDED_CACHE = new HashMap<>();

    // 泄漏点3：ThreadLocal 在线程池场景下，线程复用导致 value 一直挂在 Thread.threadLocals 上
    private static final ThreadLocal<byte[]> TL = new ThreadLocal<>();

    public static void main(String[] args) throws Exception {
        var pool = Executors.newFixedThreadPool(4);

        for (int i = 0; i < 4; i++) {
            pool.submit(() -> {
                TL.set(new byte[1024 * 512]); // 每个线程挂 512KB，不 remove 就一直留着
            });
        }

        int count = 0;
        while (true) {
            STATIC_CACHE.add(new byte[1024 * 1024]);        // 每次 1MB
            UNBOUNDED_CACHE.put("key-" + count, new byte[64 * 1024]);
            count++;
            if (count % 16 == 0) {
                System.out.println("已缓存 " + count + " MB");
                TimeUnit.MILLISECONDS.sleep(50);            // 放慢一点，方便观察 jstat
            }
        }
    }
}

import java.util.Map;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;

public class LeakFixDemo {
    // 修复1：用有界、带淘汰策略的缓存，明确容量上限
    private static final Map<String, Object> BOUNDED_CACHE =
            new java.util.LinkedHashMap<>(1024, 0.75f, true) {
                @Override
                protected boolean removeEldestEntry(Map.Entry<String, Object> eldest) {
                    return size() > 1024; // 超过 1024 条淘汰最久未访问的
                }
            };

    // 修复2：ThreadLocal 用完必须 remove，尤其是线程池场景
    private static final ThreadLocal<byte[]> TL = new ThreadLocal<>();

    // 修复3：try-with-resources 确保连接/流被关闭；监听器在销毁时反注册
    public static void main(String[] args) throws Exception {
        var pool = Executors.newFixedThreadPool(4);
        for (int i = 0; i < 4; i++) {
            pool.submit(() -> {
                try {
                    TL.set(new byte[1024 * 512]);
                    // ... 业务逻辑
                } finally {
                    TL.remove();          // 关键：归还线程前清理，否则线程复用会串数据 + 泄漏
                }
            });
        }
        ((ThreadPoolExecutor) pool).shutdown();
        // 生产建议用 Caffeine：Caffeine.newBuilder().maximumSize(10_000).expireAfterWrite(...).build()
    }
}