JVM学习—— 内存溢出异常

一、堆溢出Java heap space

表示对象实例占用的容量，到达了堆的最大容量限制

对象过大

/**
*VM Args：-Xmx12m
*/
public class JavaHeapOversizeOOM {
  static final int SIZE=2*1024*1024;
  public static void main(String[] args) throws Exception {
    int[] array = new int[SIZE];
  }
}

创建一个有2M个元素的int数组，一个int占4个字节，数组的大小略大于8M。
大对象直接进入老年代，-Xmx12m，年轻代:老年代默认为1:2，老年代为8M，导致OOM。

内存泄漏

/**
*VM Args：-Xms20m-Xmx20m-XX：+HeapDumpOnOutOfMemoryError
*/
public class JavaHeapMemoryLeakOOM {
  static class OOMObject {}
  public static void main(String[] args) {
    List<OOMObject> list = new ArrayList<OOMObject>();
    while (true) {
      list.add(new OOMObject());
    }
  }
}

往往属于程序错误，创建的对象不再使用，但GC Roots到对象之间仍有可达路径，GC无法回收，导致OOM。
除了集合类，使用ThreadLocal也要注意避免内存泄漏。
ThreadLocal针对每个线程持有一个对象，线程结束后，需要用try-finally在finally中执行ThreadLocal.set(null)，否则一旦线程出现异常，会导致对象一直无法回收。

GC overhead limit exceeded
表示执行垃圾收集的时间比例太大, 有效的运算量太小。
默认情况下, 如果GC花费的时间超过 98%, 并且GC回收的内存少于 2%, JVM就会抛出这个错误。

二、方法区溢出PermGen space

加载类太多导致方法区溢出

/**
*jdk1.6
*VM Args：-XX:MaxPermSize=10M
*/
import javassist.ClassPool;

public class PermGenSpaceOOM {

  public static void main(String[] args) throws Exception {
    for (int i = 0; i < 100000000; i++) {
      System.out.println(generate("eu.plumbr.demo.Generated" + i).getName());
    }
  }

  public static Class generate(String name) throws Exception {
    ClassPool pool = ClassPool.getDefault();
    return pool.makeClass(name).toClass();
  }
}

上面的例子，动态生成大量的类，导致OutOfMemoryError: PermGen space

常量池导致方法区溢出

/**
 * jdk1.6 -XX:MaxPermSize=10M
 */
public class ConstantPoolOOM {

  public static void main(String[] args) throws InterruptedException {
    List<String> list = new ArrayList<String>();
    int index = 0;
    while (true) {
      list.add(String.valueOf(index++).intern());
    }
  }
}

常量池属于方法区，通过String.intern()不断加入新的String常量，导致方法区OOM。
jdk1.7以后常量池移至堆中，方法区也被元空间(Metaspace)代替

三、元空间溢出Metaspace

从Java 8开始,内存结构发生重大改变, 不再使用Permgen, 而是引入一个新的空间: Metaspace. 这种改变基于多方面的考虑:

Permgen空间的具体多大很难预测。指定小了会造成 java.lang.OutOfMemoryError: Permgen size 错误, 设置多了又造成浪费。
为了GC 性能的提升, 使得垃圾收集过程中的并发阶段不再停顿, 另外对 metadata 进行特定的遍历(specific iterators)。
对G1垃圾收集器的并发 class unloading 进行深度优化。

在Java8中,将之前 PermGen 中的所有内容, 都移到了 Metaspace 空间。例如: class 名称, 字段, 方法, 字节码, 常量池, JIT优化代码, 等等。

20170922114246369.jpg

【Java8及以上】这些内存池的最大值, 由 -Xmx 和 -XX:MaxMetaspaceSize 等JVM启动参数指定。

/**
*jdk1.8
*VM Args：-XX:MaxMetaspaceSize=10M
*/
import javassist.ClassPool;

public class PermGenSpaceOOM {

  public static void main(String[] args) throws Exception {
    for (int i = 0; i < 100000000; i++) {
      System.out.println(generate("eu.plumbr.demo.Generated" + i).getName());
    }
  }

  public static Class generate(String name) throws Exception {
    ClassPool pool = ClassPool.getDefault();
    return pool.makeClass(name).toClass();
  }
}

和前面PermGen OOM的例子一样，当环境为jdk1.8，设置参数-XX:MaxMetaspaceSize=10M时，抛出java.lang.OutOfMemoryError: Metaspace

三、虚拟机栈溢出StackOverflowError

public class JavaVMStackSOF {

  private int stackLength=1;

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

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

在单个线程下，无论是由于栈帧太大还是虚拟机栈容量太小，当内存无法分配的时候，虚拟机抛出的都是StackOverflowError异常。
如果测试时不限于单线程，通过不断地建立线程的方式倒是可以产生OOM:

public class CreateNewThreadOOM {

  public static void main(String[] args) throws Exception {
    while(true){
      new Thread(new Runnable(){
        public void run() {
          try {
            Thread.sleep(100000);
          } catch(InterruptedException e) { }
        }
      }).start();
    }
  }
}

四、其他内存溢出

Unable to create new native thread

unable to create new native thread.jpg

OutOfMemoryError: Unable to create new native thread
表示程序创建的线程数量已达到上限值。

JVM向操作系统申请创建新的 native thread(原生线程)时, 如果底层操作系统创建新的 native thread 失败, JVM就会抛出相应的OutOfMemoryError，原生线程的数量受到具体环境的限制。
导致Unable to create new native thread错误的场景大多经历以下阶段:

Java程序向JVM请求创建一个新的Java线程;
JVM本地代码(native code)代理该请求, 尝试创建一个操作系统级别的native thread;
操作系统尝试创建一个新的native thread, 需要同时分配一些内存给该线程;
如果操作系统的虚拟内存已耗尽, 或者是受到32位进程的地址空间限制(约2-4GB), OS就会拒绝本地内存分配;

public class CreateNewThreadOOM {

  public static void main(String[] args) throws Exception {
    while(true){
      new Thread(new Runnable(){
        public void run() {
          try {
            Thread.sleep(10000000);
          } catch(InterruptedException e) { }
        }
      }).start();
    }
  }
}

触发创建 native 线程时的OutOfMemoryError, 表明编程存在BUG.
程序创建了成千上万的线程, 很可能就是某些地方出大问题了 —— 没有几个程序可以 Hold 住上万个线程的。
一种解决办法是执行线程转储(thread dump) 来分析具体情况。

Out of swap space
JVM启动参数指定了最大内存限制。如 -Xmx 以及相关的其他启动参数. 假若JVM使用的内存总量超过可用的物理内存, 操作系统就会用到虚拟内存。

out of swap.jpg

OutOfMemoryError: Out of swap space表明, 交换空间(swap space,虚拟内存) 不足,是由于物理内存和交换空间都不足所以导致内存分配失败。
如果native heap内存耗尽, 内存分配时, JVM 就会抛出Out of swap space错误

Requested array size exceeds VM limit
Java平台限制了数组的最大长度。各个版本的具体限制可能稍有不同, 但范围都在 1 ~ 21亿之间。

Requested array size exceeds.jpg

OutOfMemoryError: Requested array size exceeds VM limit错误, 说明要创建的数组长度超过限制。