深度剖析Java内存溢出：从堆到栈的全面解析

九转成圣

已于 2024-05-30 20:53:31 修改

阅读量1.6k

点赞数 3

分类专栏： Java高频面试栏文章标签：开发语言 java 后端 jvm

于 2024-03-07 08:14:36 首次发布

本文链接：https://blog.csdn.net/weixin_41883161/article/details/136503593

版权

Java高频面试栏专栏收录该内容

10 篇文章 1 订阅

订阅专栏

本文详细探讨了Java内存溢出的多种类型，包括堆溢出、栈溢出、常量池溢出、元空间溢出和直接内存溢出，通过示例代码和技术解析，提供了预防和解决这些问题的方法，强调了合理设置JVM参数和监控内存的重要性。

摘要由CSDN通过智能技术生成

Java 内存溢出是指在 Java 程序运行过程中，超出 JVM 分配的内存范围，导致内存不足的异常情况。本文将深入探讨 Java 内存溢出的各种类型，包括堆溢出、栈溢出、运行时常量池溢出、元空间溢出、直接内存溢出等，并提供详细的示例代码和技术解析。

一、堆溢出（Heap Overflow）

堆内存用于存储对象实例和数组。当持续创建新对象且无法及时回收内存时，会导致堆内存溢出。

示例代码：

// 设置 JVM 参数：-Xms20m -Xmx20m
  public class HeapOverflowDemo {
      private static void heapOutOfMemory() {
          List<Object> list = new ArrayList<>();
          while (true) {
              list.add(new Object());
          }
      }
  
      public static void main(String[] args) {
          heapOutOfMemory();
      }
  }

异常信息：

Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
  	at java.util.Arrays.copyOf(Arrays.java:3210)
  	at java.util.ArrayList.grow(ArrayList.java:265)
  	at java.util.ArrayList.add(ArrayList.java:462)
  	at HeapOverflowDemo.heapOutOfMemory(HeapOverflowDemo.java:6)
  	at HeapOverflowDemo.main(HeapOverflowDemo.java:10)

技术解析：

原因：不断向 ArrayList 中添加新对象，最终耗尽堆内存。
解决方案

：
- 增大堆内存大小：调整 JVM 参数，如 -Xms 和 -Xmx。
- 分析内存泄漏：使用工具（如 VisualVM、JProfiler）分析内存使用情况，定位和修复内存泄漏。

二、栈溢出（Stack Overflow）

栈内存用于存储方法调用时的栈帧。递归调用过多或创建大量线程时，会导致栈内存溢出。

单线程栈溢出

示例代码：

public class StackOverflowDemo {
      private static void stackOverflowError() {
          stackOverflowError();
      }
  
      public static void main(String[] args) {
          stackOverflowError();
      }
  }

异常信息：

Exception in thread "main" java.lang.StackOverflowError
  	at StackOverflowDemo.stackOverflowError(StackOverflowDemo.java:3)
  	at StackOverflowDemo.stackOverflowError(StackOverflowDemo.java:3)
  	...

多线程栈溢出

示例代码：

public class MultiThreadStackOverflowDemo {
      /**
       * 设置 JVM 参数：-Xss2m
       */
      private static void stackOverflowError2() {
          while (true) {
              new Thread(() -> {
                  while (true) {
                  }
              }).start();
          }
      }
  
      public static void main(String[] args) {
          stackOverflowError2();
      }
  }

异常信息：

  java.lang.OutOfMemoryError: unable to create new native thread

技术解析：

单线程栈溢出原因：递归调用深度过大，栈帧超过栈内存限制。
多线程栈溢出原因：创建大量线程，每个线程需要分配栈空间，最终耗尽可用内存。
解决方案

：
- 优化递归：使用迭代替代递归，或增加栈内存大小（-Xss 参数）。
- 控制线程数量：限制并发线程数，使用线程池管理线程。

三、运行时常量池溢出（Runtime Constant Pool Overflow）

运行时常量池是方法区的一部分，用于存放编译期间生成的字面量和符号引用。常量池中的数据过多时，会导致内存溢出。

示例代码：

public class RuntimeConstantPoolOOM {
      /**
       * 设置 JVM 参数：-Xms6m -Xmx6m
       */
      private static void runtimeConstantPoolOOM() {
          Set<String> set = new HashSet<>();
          int i = 0;
          while (true) {
              set.add(String.valueOf(i++).intern());
          }
      }
  
      public static void main(String[] args) {
          runtimeConstantPoolOOM();
      }
  }

技术解析：

原因：不断将新的字符串常量加入常量池，超出内存限制。
解决方案

：
- 增大方法区内存：调整 -XX:PermSize 和 -XX:MaxPermSize 参数（Java 8 之前）。
- 使用 StringBuilder：避免大量字符串常量拼接。

四、元空间溢出（Metaspace Overflow）

元空间用于存储类的元数据。Java 8 之后，元空间取代了永久代。元空间大小不足时，会导致内存溢出。

示例代码：

  // 设置 JVM 参数：-XX:MetaspaceSize=12M -XX:MaxMetaspaceSize=12M

启动 Spring Boot 项目即可出现元空间内存溢出。

异常信息：

Exception in thread "background-preinit" java.lang.OutOfMemoryError: Metaspace
  Exception in thread "main" java.lang.OutOfMemoryError: Metaspace

技术解析：

原因：类加载过多，元空间被耗尽。
解决方案

：
- 增大元空间大小：调整 -XX:MetaspaceSize 和 -XX:MaxMetaspaceSize 参数。
- 优化类加载：减少动态类加载，使用类加载器缓存。

五、直接内存溢出（Direct Memory Overflow）

直接内存用于 NIO 中的缓冲区，使用 Unsafe 类直接分配内存。直接内存大小可以通过 JVM 参数 -XX:MaxDirectMemorySize 设置。

示例代码：

import sun.misc.Unsafe;
  
  import java.lang.reflect.Field;
  
  public class DirectMemoryOOM {
      private static final int _1MB = 1024 * 1024;
  
      public static void main(String[] args) throws Exception {
          Field unsafeField = Unsafe.class.getDeclaredFields()[0];
          unsafeField.setAccessible(true);
          Unsafe unsafe = (Unsafe) unsafeField.get(null);
          while (true) {
              unsafe.allocateMemory(_1MB);
          }
      }
  }