/**
 * Java虚拟机栈和本地方法机栈异常（单线程操作下）
 * VM Args: -Xss160k（Mac 64Bit要求最低栈内存为160K）
 * 使用-Xss参数减少栈内存容量。
 * 结果：抛出StackOverflowError异常，异常出现时输出的堆栈深度相应缩小。
 *
 * @author wugang
 * date: 2020-06-04 15:23
 **/
public class VMStackSOF {
    private int stackLength = 1;

    private void stackLeak() {
        stackLength++;
        stackLeak();
    }


    public static void main(String[] args) {
        VMStackSOF stackSOF = new VMStackSOF();
        try {
            stackSOF.stackLeak();
        } catch (Throwable e) {
            System.out.println("stack length: " + stackSOF.stackLength);
            throw e;
        }
    }
}

/**
 * Java虚拟机栈和本地方法机栈异常（单线程操作下）
 * 定义大量的本地变量，增大此方法帧中本地变量表的长度
 * 结果：抛出StackOverflowError异常，异常出现时输出的堆栈深度相应缩小。
 *
 * @author wugang
 * date: 2020-06-04 15:23
 **/
public class VMStackSOF02 {
    private static int stackLength = 1;

    public static void test() {
        long unused1, unused2, unused3, unused4, unused5, unused6, unused7, unused8, unused9, unused10,
                unused11, unused12, unused13, unused14, unused15, unused16, unused17, unused18, unused19, unused20,
                unused21, unused22, unused23, unused24, unused25, unused26, unused27, unused28, unused29, unused30,
                unused31, unused32, unused33, unused34, unused35, unused36, unused37, unused38, unused39, unused40,
                unused41, unused42, unused43, unused44, unused45, unused46, unused47, unused48, unused49, unused50,
                unused51, unused52, unused53, unused54, unused55, unused56, unused57, unused58, unused59, unused60,
                unused61, unused62, unused63, unused64, unused65, unused66, unused67, unused68, unused69, unused70,
                unused71, unused72, unused73, unused74, unused75, unused76, unused77, unused78, unused79, unused80,
                unused81, unused82, unused83, unused84, unused85, unused86, unused87, unused88, unused89, unused90,
                unused91, unused92, unused93, unused94, unused95, unused96, unused97, unused98, unused99, unused100;
        stackLength++;
        test();
        unused1 = unused2 = unused3 = unused4 = unused5 = unused6 = unused7 = unused8 = unused9 = unused10 = unused11 =
                unused12 = unused13 = unused14 = unused15 = unused16 = unused17 = unused18 = unused19 = unused20 = unused21 = unused22 = unused23 = unused24 = unused25 = unused26 = unused27 = unused28 = unused29 = unused30 = unused31 = unused32 = unused33 = unused34 = unused35 = unused36 = unused37 = unused38 = unused39 = unused40 = unused41 = unused42 = unused43 = unused44 = unused45 = unused46 = unused47 = unused48 = unused49 = unused50 = unused51 = unused52 = unused53 = unused54 = unused55 = unused56 = unused57 = unused58 = unused59 = unused60 = unused61 = unused62 = unused63 = unused64 = unused65 = unused66 = unused67 = unused68 = unused69 = unused70 = unused71 = unused72 = unused73 = unused74 = unused75 = unused76 = unused77 = unused78 = unused79 = unused80 = unused81 = unused82 = unused83 = unused84 = unused85 = unused86 = unused87 = unused88 = unused89 = unused90 = unused91 = unused92 = unused93 = unused94 = unused95 = unused96 =
                        unused97 = unused98 = unused99 = unused100 = 0;
    }

    public static void main(String[] args) {
        try {
            test();
        } catch (Throwable e) {
            System.out.println("stack length: " + stackLength);
            throw e;
        }
    }
}

/**
 * 多线程下，Java虚拟机栈和本地方法栈OOM异常
 * VM Args:-Xss2M
 *
 * @author wugang
 * date: 2020-06-04 16:38
 **/
public class VMStackOOM {

    private void dontStop() {
        while (true) {

        }
    }

    public void stackLeakByThread() {
        while (true) {
            Thread thread = new Thread(() -> dontStop());
            thread.start();
        }
    }

    public static void main(String[] args) {
        VMStackOOM vmStackOOM = new VMStackOOM();
        vmStackOOM.stackLeakByThread();
    }

}

/**
 * Java堆内存异常测试
 * VM Args: -Xms20m -Xmx20m -XX:+HeapDumpOnOutOfMemoryError
 **/
public class JavaHeapOOM {
    private static class OOMObject {

    }

    public static void main(String[] args) {
        List<OOMObject> list = Lists.newArrayList();
        while (true) {
            list.add(new OOMObject());
        }
    }
}

/**
 * 方法区的OOM异常：
 * - JDK8之前：指定老年代（方法区的大小固定为10M，不能进行自动扩展）
 * VM Args: -XX:PermSize=10M -XX:MaxPermSize=10M
 *
 * - JDK8：完全废除了老年代，用元空间代替。
 * VM Args: -XX:MetaspaceSize=10M -XX:MaxMetaspaceSize=10M
 *
 * @author wugang
 * date: 2020-06-04 18:44
 **/
public class JavaMethodAreaOOM {

    static class OOMObject {}

    /**
     * 借助CGLib使得方法区出现内存溢出异常：
     * 方法区的主要职责是用于存放类型的相关信息：如类名、访问修饰符、常量池、字段描述、方法描述等。
     * 对于这部分区域的测试，基本的思路是：运行时产生大量的类去填满方法区，直到溢出为止。
     * 所以：可以借助CGLib直接操作字节码，运行时生成了大量的动态类。
     * 注意：
     * 当前的很多主流框架，如Spring、Hibernate对类进行增强时，都会使用到 CGLib这类字节码技术，
     * 当增强的类越多，就需要越大的方法区以保证动态生成的新类型可以载入内存。
     */
    public static void main(String[] args) {
        while (true) {
            Enhancer enhancer = new Enhancer();
            enhancer.setSuperclass(OOMObject.class);
            enhancer.setUseCache(false);
            enhancer.setCallback(new MethodInterceptor() {
                @Override
                public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                    return methodProxy.invokeSuper(o, args);
                }
            });
            enhancer.create();
        }
    }

}

import java.util.HashSet;
import java.util.Set;

/**
 * 方法区（运行时常量池）的OOM异常，（方法区在JDK8后开始废除，之前也被称为永久代）
 * - 在JDK 6或更早之前的HotSpot虚拟机中，常量池都是分配在永久代中，
 * 我们可以通过-XX:PermSize和-XX:M axPermSize限制永久代的大小，即可间接限制其中常量池的容量。
 * 如：VM Args:-XX:PermSize=6M -XX:MaxPermSize=6M
 *
 * @author wugang
 * date: 2020-06-04 17:36
 **/
public class RuntimeConstantPoolOOM {

    /**
     * JDK6来运行代码，抛出异常：
     * Exception in thread "main" java.lang.OutOfMemoryError: PermGen space
     * at java.lang.String.intern(Native Method)
     * 说明运行时常量池是属于方法区(即JDK 6的HotSpot虚拟机中的永久代)的一部分。
     *
     * 注意：
     * 无论是在JDK7中继续使用-XX:MaxPermSize参数或者在JDK8及以上版本使用-XX:MaxMeta-spaceSize参数
     * 把方法区容量同样限制在6MB，也都不会重现JDK6中的溢出异常，循环将一直进行下去，永不停歇。
     *
     * 因为自JDK7起，原本存放在永久代的字符串常量池被移至Java堆之中，
     * 所以在JDK7及以上版本，限制方法区的容量对该测试用例来说是毫无意义的。
     *
     * 但使用-Xmx参数限制最大堆到6MB就能够看到下面两种运行结果之一，具体取决于哪里的对象分配时产生了溢出：
     * - OOM异常一：
     * Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
     * at java.base/java.lang.Integer.toString(Integer.java:440)
     * at java.base/java.lang.String.valueOf(String.java:3058)
     * - OOM异常二：
     * Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
     * at java.base/java.util.HashMap.resize(HashMap.java:699)
     * at java.base/java.util.HashMap.putVal(HashMap.java:658)
     * at java.base/java.util.HashMap.put(HashMap.java:607)
     * at java.base/java.util.HashSet.add(HashSet.java:220)
     *
     */
    private static void runByJDK6() {
        // 使用Set保持着常量池引用，避免Full GC回收常量池行为
        Set<String> set = new HashSet<>();
        // 在short范围内足以让6MB的PermSize产生OOM了
        short i = 0;
        while (true) {
            set.add(String.valueOf(i++).intern());
        }
    }

    public static void main(String[] args) {
        runByJDK6();
    }

}

public native String intern();

/**
 * - 在JDK 6中运行，会得到三个false；
 * 在JDK 6中，intern()方法会把首次遇到的字符串实例复制到永久代（方法区）的字符串常量池中存储，
 * 返回的也是永久代里面这个字符串实例的引用，而由StringBuilder创建的字符串对象实例在Java堆上，
 * 所以必然不可能是同一个引用，结果将返回false。
 *
 * - 而在JDK 7后中运行，会得到一个true、一个false和一个true；
 * 因为JDK7中，intern()方法实现就不需要再拷贝字符串的实例到永久代了，既然字符串常量池已经移到Java堆中，
 * 那只需要在常量池里记录一下首次出现的实例引用即可。
 * 因此intern()返回的引用和由StringBuilder创建的那个字符串实例就是同一个。
 * 而对str2比较返回false，这是因为java这个字符串在执行StringBuilder()之前就已经出现过了，(在加载sun.misc.Version这个类的时候进入常量池的)
 * 字符串常量池中已经有它的引用，不符合intern()方法要求“首次遇到”的原则，“JVM调优”这个字符串则是首次出现的，因此结果返回true。
 * 而str3和str1一样，"JDKJVM"这个字符串则是首次出现。
 *
 */
private static void compare() {
    String str1 = new StringBuilder().append("JVM").append("调优").toString();
    System.out.println(str1.intern() == str1);
    // java这个字符串在执行StringBuilder()之前就已经出现过了，在加载sun.misc.Version这个类的时候进入常量池的。
    /*
     * 参考：https://www.zhihu.com/question/51102308/answer/124441115
     * sun.misc.Version类会在JDK类库的初始化过程中被加载并初始化，
     * 而在初始化时它需要对静态常量字段根据指定的常量值（ConstantValue）做默认初始化，
     * 此时被 sun.misc.Version.launcher 静态常量字段所引用的"java"字符串字面量就被intern到HotSpot VM的字符串常量池StringTable里了。
     */
    String str2 = new StringBuilder().append("ja").append("va").toString();
    System.out.println(str2.intern() == str2);
    // 而JDKJVM这个字符串则是首次出现
    String str3 = new StringBuilder().append("JDK").append("JVM").toString();
    System.out.println(str3.intern() == str3);
}

/**
 * java中的String是引用类型。创建的String对象，实际上存储的是一个地址。
 * 所以下面a和b都是引用类型，其存储的是字符串的地址。它们本身存储在Java虚拟机栈的局部变量表中。
 * - a：直接将字符串存储在常量池中，然后将a指向常量池种中的"JVM"。
 * - b：先将字符串"JVM"存储在常量池中，然后在heap中创建一个对象，该对象指向常量池中的"JVM"，最后将b指向heap中创建的这个对象。
 *
 * 也就是说，a和b存储的内容是一样的，都是"JVM"，但地址不一样：a中保存的是常量池中"JVM"的地址，b保存的是heap中那个对象的地址，
 *
 * 双等于号"=="比较的是地址，equals()比较的是内容。
 */
private static void compareStr() {
    String a = "JVM";
    // new一个对象
    String b = new String("JVM");
    // == 比较地址是否相等
    // 都在运行时常量池中
    System.out.println("JVM" == a); // true
    System.out.println(a.intern() == a); // true
    // a为字符字面量（存储在运行时常量池中），b为对象（存储在堆中），所以不等。
    System.out.println(a == b); // false
    System.out.println(a.intern() == b); // false

    System.out.println(a.equals(b));  // true
}

import sun.misc.Unsafe;

import java.lang.reflect.Field;

/**
 * 直接内存OOM异常：使用unsafe分配本机内存
 * VM Args: -Xmx20M -XX:MaxDirectMemorySize=10M
 *
 * @author wugang
 * date: 2020-06-04 19:43
 **/
public class DirectMemoryOOM {
    private static final int _1MB = 1024 * 1024;


    /**
     * 越过了DirectByteBuffer类直接通过反射获取Unsafe实例进行内存分配。
     * （Unsafe类的getUnsafe()方法指定只有引导类加载器才会返回实例，体现了设计者希望只有虚拟机标准类库里面的类才能使用Unsafe的功能，在JDK 10时才将Unsafe的部分功能通过VarHandle开放给外部使用）
     * 因为虽然使用DirectByteBuffer分配内存也会抛出内存溢出异常，但它抛出异常时并没有真正向操作系统申请分配内存，
     * 而是通过计算得知内存无法分配就会在代码里手动抛出溢出异常，真正申请分配内存的方法是Unsafe::allocateMemory ()。
     *
     * 抛出异常：
     * Exception in thread "main" java.lang.OutOfMemoryError
     * at sun.misc.Unsafe.allocateMemory(Native Method)
     */
    public static void main(String[] args) throws IllegalAccessException {
        Field unsafeField = Unsafe.class.getDeclaredFields()[0];
        unsafeField.setAccessible(true);
        Unsafe unsafe = (Unsafe) unsafeField.get(null);
        while (true) {
            unsafe.allocateMemory(_1MB);
        }
    }

}