Java编程常见内存溢出异常与代码示例

发布时间：2020-05-25 08:08:13 所属栏目：Java 来源：互联网

导读：Java堆是用来存储对象实例的,因此如果我们不断地创建对象,并且保证GCRoot和创建的对象之间有可达路径以免对象被垃圾回收,那么当创建的对象过多时,会导致heap内存不足,进而引发OutOfMemoryError异常.

Java 堆是用来存储对象实例的,因此如果我们不断地创建对象,并且保证 GC Root 和创建的对象之间有可达路径以免对象被垃圾回收,那么当创建的对象过多时,会导致 heap 内存不足,进而引发 OutOfMemoryError 异常.

/**
 * @author xiongyongshun
 * VM Args: java -Xms10m -Xmx10m -XX:+HeapDumpOnOutOfMemoryError
 */
public class OutOfMemoryErrorTest {
  public static void main(String[] args) {
    List<Integer> list = new ArrayList<>();
    int i = 0;
    while (true) {
      list.add(i++);
    }
  }
}

上面是一个引发 OutOfMemoryError 异常的代码,我们可以看到,它就是通过不断地创建对象,并将对象保存在 list 中防止其被垃圾回收,因此当对象过多时,就会使堆内存溢出。

通过 java -Xms10m -Xmx10m -XX:+HeapDumpOnOutOfMemoryError 我们设置了堆内存为 10 兆,并且使用参数 -XX:+HeapDumpOnOutOfMemoryError 让 JVM 在发生 OutOfMemoryError 异常时打印出当前的内存快照以便于后续分析.

编译运行上述代码后,会有如下输出:

>>> java -Xms10m -Xmx10m -XX:+HeapDumpOnOutOfMemoryError com.test.OutOfMemoryErrorTest                                              16-10-02 23:35
java.lang.OutOfMemoryError: Java heap space
Dumping heap to java_pid1810.hprof ...
Heap dump file created [14212861 bytes in 0.125 secs]
Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
    at java.util.Arrays.copyOf(Arrays.java:3210)
    at java.util.Arrays.copyOf(Arrays.java:3181)
    at java.util.ArrayList.grow(ArrayList.java:261)
    at java.util.ArrayList.ensureExplicitCapacity(ArrayList.java:235)
    at java.util.ArrayList.ensureCapacityInternal(ArrayList.java:227)
    at java.util.ArrayList.add(ArrayList.java:458)
    at com.test.OutOfMemoryErrorTest.main(OutOfMemoryErrorTest.java:15)

Java 栈 StackOverflowError

我们知道,JVM 的运行时数据区中有一个叫做虚拟机栈的内存区域,此区域的作用是: 每个方法在执行时都会创建一个栈帧,用于存储局部变量表,操作数栈,方法出口等信息.

因此我们可以创建一个无限递归的递归调用,当递归深度过大时,就会耗尽栈空间,进而导致了 StackOverflowError 异常.

下面是具体的代码:

/**
 * @author xiongyongshun
 * VM Args: java -Xss64k
 */
public class OutOfMemoryErrorTest {
  public static void main(String[] args) {
    stackOutOfMemoryError(1);
  }

  public static void stackOutOfMemoryError(int depth) {
    depth++;
    stackOutOfMemoryError(depth);
  }
}

当编译运行上述的代码后,会输出如下异常信息:

Exception in thread "main" java.lang.StackOverflowError
  at com.test.OutOfMemoryErrorTest.stackOutOfMemoryError(OutOfMemoryErrorTest.java:27)

方法区内存溢出

注意,因为 JDK8 已经移除了永久代,取而代之的是 metaspace,因此在 JDK8 中,下面两个例子都不会导致 java.lang.OutOfMemoryError: PermGen space 异常.

运行时常量池溢出

在 Java 1.6 以及之前的 HotSpot JVM 版本时,有永久代的概念,即 GC 的分代收集机制是扩展至方法区的. 在方法区中,有一部分内存是用于存储常量池,因此如果代码中常量过多时,就会耗尽常量池内存,进而导致内存溢出.那么如何添加大量的常量到常量池呢? 这时就需要依靠 String.intern() 方法了. String.intern() 方法的作用是: 若此 String 的值在常量池中已存在,则这个方法返回常量池中对应字符串的引用; 反之将此 String 所包含的值添加到常量池中,并返回此 String 对象的引用. 在 JDK 1.6 以及之前的版本中,常量池分配在永久代中,因此我们可以通过设置参数 “-XX:PermSize” 和 “-XX:MaxPermSize” 来间接限制常量池的大小.

注意,上面所说的 String.intern() 方法和常量池的内存分布仅仅针对于 JDK 1.6 及之前的版本,在 JDK 1.7 或以上的版本中,由于去除了永久代的概念,因此内存布局稍有不同.

下面是实现常量池内存溢出的代码例子:

/**
 * @author xiongyongshun
 * VM Args: -XX:PermSize=10M -XX:MaxPermSize=10M 
 */
public class RuntimeConstantPoolOOMTest {
  public static void main(String[] args) {
    List<String> list = new ArrayList<String>();
    int i = 0;
    while (true) {
      list.add(String.valueOf(i++).intern());
    }
  }
}

我们看到,这个例子中,正是使用了 String.intern() 方法,向常量池中添加了大量的字符串常量,因而导致了常量池的内存溢出.

我们通过 JDK1.6 编译并运行上面的代码,会有如下输出:

Exception in thread "main" java.lang.OutOfMemoryError: PermGen space
    at java.lang.String.intern(Native Method)
    at com.test.RuntimeConstantPoolOOMTest.main(RuntimeConstantPoolOOMTest.java:16)

需要注意的是,如果通过 JDK1.8 来编译运行上面代码的话,会有如下警告,并且不会产生任何的异常:

>>> java -XX:PermSize=10M -XX:MaxPermSize=10M com.test.RuntimeConstantPoolOOMTest                                                 16-10-03 0:23
Java HotSpot(TM) 64-Bit Server VM warning: ignoring option PermSize=10M; support was removed in 8.0
Java HotSpot(TM) 64-Bit Server VM warning: ignoring option MaxPermSize=10M; support was removed in 8.0

方法区的内存溢出

方法区作用是存放 Class 的相关信息,例如类名,类访问修饰符,字段描述,方法描述等. 因此如果方法区过小,而加载的类过多,就会造成方法区的内存溢出.

//VM Args: -XX:PermSize=10M -XX:MaxPermSize=10M
public class MethodAreaOOMTest {
  public static void main(String[] args) {
    while (true) {
      Enhancer enhancer = new Enhancer();
      enhancer.setSuperclass(MethodAreaOOMTest.class);
      enhancer.setUseCache(false);
      enhancer.setCallback(new MethodInterceptor() {
        public Object intercept(Object o,Method method,Object[] objects,MethodProxy methodProxy) throws Throwable {
          return methodProxy.invokeSuper(o,objects);
        }
      });

      enhancer.create();
    }
  }
}

上面的代码中,我们借助 CGlib 来动态地生成大量的类,在 JDK6 下,运行上面的代码会产生 OutOfMemoryError: PermGen space 异常:

/System/Library/Frameworks/JavaVM.framework/Versions/1.6/Home/bin/java -jar -XX:PermSize=10M -XX:MaxPermSize=10M target/Test-1.0-SNAPSHOT.jar

输出结果如下:

Caused by: java.lang.OutOfMemoryError: PermGen space
    at java.lang.ClassLoader.defineClass1(Native Method)
    at java.lang.ClassLoader.defineClassCond(ClassLoader.java:637)
    at java.lang.ClassLoader.defineClass(ClassLoader.java:621)
    ... 11 more

MetaSpace 内存溢出

在方法区的内存溢出内存溢出一节中,我们提到,JDK8 没有了永久代的概念,因此那两个例子在 JDK8 下没有实现预期的效果. 那么在 JDK8 下,是否有类似方法区内存溢出之类的错误呢? 当然有的. 在 JDK8 中,使用了 MetaSpace 的区域来存放 Class 的相关信息,因此当 MetaSpace 内存空间不足时,会抛出 java.lang.OutOfMemoryError: Metaspace 异常.

我们还是以上面提到的例子为例:

//VM Args: -XX:MaxMetaspaceSize=10M
public class MethodAreaOOMTest {
  public static void main(String[] args) {
    while (true) {
      Enhancer enhancer = new Enhancer();
      enhancer.setSuperclass(MethodAreaOOMTest.class);
      enhancer.setUseCache(false);
      enhancer.setCallback(new MethodInterceptor() {
        public Object intercept(Object o,objects);
        }
      });

      enhancer.create();
    }
  }
}

此例子的代码部分没有改动,唯一的区别是我们需要使用 JDK8 来运行这段代码,并且设着参数 -XX:MaxMetaspaceSize=10M,这个参数告诉 JVM Metaspace 的最大大小是 10M.

接着我们使用 JDK8 来编译运行这个例子,输出如下异常:

>>> java -jar -XX:MaxMetaspaceSize=10M target/Test-1.0-SNAPSHOT.jar
Exception in thread "main" java.lang.OutOfMemoryError: Metaspace
  at net.sf.cglib.core.AbstractClassGenerator.generate(AbstractClassGenerator.java:345)
  at net.sf.cglib.proxy.Enhancer.generate(Enhancer.java:492)
  at net.sf.cglib.core.AbstractClassGenerator$ClassLoaderData.get(AbstractClassGenerator.java:114)
  at net.sf.cglib.core.AbstractClassGenerator.create(AbstractClassGenerator.java:291)
  at net.sf.cglib.proxy.Enhancer.createHelper(Enhancer.java:480)
  at net.sf.cglib.proxy.Enhancer.create(Enhancer.java:305)
  at com.test.MethodAreaOOMTest.main(MethodAreaOOMTest.java:22)

总结

以上就是本文关于Java编程常见内存溢出异常与代码示例的全部内容，希望对大家有所帮助。感兴趣的朋友可以继续参阅本站其他相关专题，如有不足之处，欢迎留言指出。感谢朋友们对本站的支持！

（编辑：安卓应用网）

【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!