Java-JVM OutOfMemory 情况（JDK8）

-Xms：初始值
-Xmx：最大值
-Xmn：最小值

public static void main(String[] args) {
    List<byte[]> list = new ArrayList<>();
    int i = 0;
    while (true) {
        list.add(new byte[8 * 1024 * 1024]);
        System.out.println(++i);
    }
}

# JDK6 新增错误类型。当 GC 为释放很小空间占用大量时间时抛出。
# （超过 98% 以上的时间去释放小于 2% 的堆空间）
java.lang.OutOfMemoryError: GC overhead limit exceeded

# 关闭上述检查功能，通常不治本，最终会 Java heap space。应查看系统是否有使用大内存的代码或死循环
-XX:-UseGCOverheadLimit

static class Key {
    Integer id;
    Key(Integer id) {
        this.id = id;
    }
    // @Override
    // public int hashCode() {
    //     return id.hashCode();
    // }
    //
    // @Override
    // public boolean equals(Object o) {
    //     boolean response = false;
    //     if (o instanceof Key) {
    //         response = (((Key) o).id).equals(this.id);
    //     }
    //     return response;
    // }
}

public static void main(String[] args) {
    Map<Key, String> m = new HashMap<>();
    int x = 0;
    while (true) {
        for (int i = 0; i < 500; i++) {
            if (!m.containsKey(new Key(i))) {
                m.put(new Key(i), "Number:" + i);
            }
        }
        System.out.println(x++);
    }
}

public static void main(String[] args) {
    Map map = System.getProperties();
    Random r = new Random();
    while (true) {
        map.put(r.nextInt(), "Oracle Java");
    }
}

# 初始空间大小，达到该值就会触发垃圾收集进行类型卸载，同时GC会对该值进行调整
# 如果释放了大量的空间，就适当降低该值。
# 如果释放了很少的空间，那么在不超过 MaxMetaspaceSize 下适当提高该值。
-XX:MetaspaceSize

# 最大空间，默认没有限制。
# 防止因为某些情况导致 Metaspace 无限的使用本地内存，影响到其他程序。应设置大小。
-XX:MaxMetaspaceSize


# Metaspace 增长时的最大幅度。
-XX:MaxMetaspaceExpansion

# Metaspace 增长时的最小幅度。
-XX:MinMetaspaceExpansion


# 当进行过Metaspace GC之后， 会计算当前Metaspace的空闲空间比，如果空闲比大于这个参数，那么虚拟机会释放 Metaspace 的部分空间。在本机该参数的默认值为70，也就是70%。
-XX:MaxMetaspaceFreeRatio

# 当进行过Metaspace GC之后，会计算当前 Metaspace 的空闲空间比，如果空闲比小于这个参数，那么虚拟机将增长 Metaspace 的大小。在本机该参数的默认值为40，也就是40%。
# 设置该参数可以控制 Metaspace 的增长的速度，太小的值会导致 Metaspace 增长的缓慢，Metaspace 的使用逐渐趋于饱和，可能会影响之后类的加载。而太大的值会导致 Metaspace 增长的过快，浪费内存。
-XX:MinMetaspaceFreeRatio

public static void main(String[] args) {
    ClassLoadingMXBean loadingBean = ManagementFactory.getClassLoadingMXBean();
    // 借助 CGlib 来动态地生成大量的 Class
    while (true) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(MetaSpaceOomError.class);
        enhancer.setCallbackTypes(new Class[]{Dispatcher.class, MethodInterceptor.class});
        enhancer.setCallbackFilter(new CallbackFilter() {
            @Override
            public int accept(Method method) {
                return 1;
            }

            @Override
            public boolean equals(Object obj) {
                return super.equals(obj);
            }
        });
        Class clazz = enhancer.createClass();

        System.out.println(clazz.getName() + "===================================");
        // 显示数量信息(共加载过的类型数目,当前还有效的类型数目,已经被卸载的类型数目)
        System.out.println("total:" + loadingBean.getTotalLoadedClassCount());
        System.out.println("active:" + loadingBean.getLoadedClassCount());
        System.out.println("unloaded:" + loadingBean.getUnloadedClassCount());
    }
}

# 堆外内存最大值
-XX:MaxDirectMemorySize

private static int ONE_MB = 1024 * 1024;
private static int index = 0;

public static void main(String[] args) {
    try {
        System.out.println(VM.maxDirectMemory() / ONE_MB);
        ByteBuffer.allocateDirect(ONE_MB * 100);

        // 直接内存操作
        Field field = Unsafe.class.getDeclaredField("theUnsafe");
        field.setAccessible(true);
        Unsafe unsafe = (Unsafe) field.get(null);
        while (true) {
            index++;
            // 分配内存
            long l = unsafe.allocateMemory(ONE_MB);
            // 释放内存
            unsafe.freeMemory(l);
        }
    } catch (Exception | Error e) {
        System.out.println("index:" + index);
        e.printStackTrace();
    }
}

# 每个线程的堆栈大小
-Xss

private static int num = 1;

public void testStack() throws StackOverflowError {
    num++;
    this.testStack();
}

public static void main(String[] agrs) {
    try {
        StackOomError t = new StackOomError();
        t.testStack();
    } catch (StackOverflowError stackOverflowError) {
        System.out.println(num);
        stackOverflowError.printStackTrace();
    }
}

public static void main(String[] args) {
    try {
        int[] arr = new int[Integer.MAX_VALUE];
    } catch (Throwable t) {
        t.printStackTrace();
    }
}