深入理解JVM - 内存溢出实战

最新推荐文章于 2024-09-26 16:58:35 发布
最新推荐文章于 2024-09-26 16:58:35 发布
阅读量1k 收藏 6
点赞数
分类专栏： # JVM 文章标签： 堆内存溢出 栈内存溢出 元数据区域内存溢出 直接内存溢出 内存泄漏
凡是过去，皆为序幕
本文链接：https://blog.csdn.net/xiaolyuh123/article/details/103729222
版权

Java堆溢出

Java堆用于存储对象实例，只要不断地创建对象，当对象数量到达最大堆的容量限制后就会产生内存溢出异常。最常见的内存溢出就是存在大的容器，而没法回收，比如：Map，List等。

  • 内存溢出：内存空间不足导致，新对象无法分配到足够的内存；
  • 内存泄漏：应该释放的对象没有被释放，多见于自己使用容器保存元素的情况下。

出现下面信息就可以断定出现了堆内存溢出。

java.lang.OutOfMemoryError: Java heap space

保证GC Roots到对象之间有可达路径来避免垃圾回收机制清除这些对象

示例

设置JVM内存参数：

-verbose:gc -Xms20m -Xmx20m -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=D:\dump

/**
 * java 堆内存溢出
 * <p>
 * VM Args: -Xms20m -Xmx20m -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=D:\dump
 *
 * @author yuhao.wang3
 * @since 2019/11/30 17:09
 */
public class HeapOutOfMemoryErrorTest {
    public static void main(String[] args) throws InterruptedException {
        // 模拟大容器
        List<Object> list = Lists.newArrayList();
        for (long i = 1; i > 0; i++) {
            list.add(new Object());
            if (i % 100_000 == 0) {
                System.out.println(Thread.currentThread().getName() + "::" + i);
            }
        }
    }
}

运行结果

[GC (Allocation Failure)  5596K->1589K(19968K), 0.0422027 secs]
main::100000
main::200000
[GC (Allocation Failure)  7221K->5476K(19968K), 0.0144103 secs]
main::300000
[GC (Allocation Failure)  9190K->9195K(19968K), 0.0098252 secs]
main::400000
main::500000
[Full GC (Ergonomics)  17992K->13471K(19968K), 0.3431052 secs]
main::600000
main::700000
main::800000
[Full GC (Ergonomics)  17127K->16788K(19968K), 0.1581969 secs]
[Full GC (Allocation Failure)  16788K->16758K(19968K), 0.1994445 secs]
java.lang.OutOfMemoryError: Java heap space
Dumping heap to D:\dump\java_pid7432.hprof ...
Heap dump file created [28774262 bytes in 0.221 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.xiaolyuh.HeapOutOfMemoryErrorTest.main(HeapOutOfMemoryErrorTest.java:23)
Disconnected from the target VM, address: '127.0.0.1:61622', transport: 'socket'

分析工具

JDK自带的jvisualvm.exe工具可以分析.hprof和.dump文件。

首先需要找出最大的对象，判断最大对象的存在是否合理，如何合理就需要调整JVM内存大小。如果不合理，那么这个对象的存在，就是最有可能是引起内存溢出的根源。通过GC Roots的引用链信息，就可以比较准确地定位出泄露代码的位置。

  1. 查询最大对象

1.png

  1. 找出具体的对象

2.png

解决方案

  1. 优化代码，去除大对象；
  2. 调整JVM内存大小（-Xmx与-Xms）；

超出GC开销限制

当出现java.lang.OutOfMemoryError: GC overhead limit exceeded异常信息时，表示超出了GC开销限制。当超过98%的时间用来做GC，但是却回收了不到2%的堆内存时会抛出此异常。

异常栈

[Full GC (Ergonomics)  19225K->19225K(19968K), 0.1044070 secs]
[Full GC (Ergonomics)  19227K->19227K(19968K), 0.0684710 secs]
java.lang.OutOfMemoryError: GC overhead limit exceeded
Dumping heap to D:\dump\java_pid17556.hprof ...
Heap dump file created [34925385 bytes in 0.132 secs]
Exception in thread "main" java.lang.OutOfMemoryError: GC overhead limit exceeded
[Full GC (Ergonomics)  19257K->933K(19968K), 0.0403569 secs]
	at com.xiaolyuh.HeapOutOfMemoryErrorTest.main(HeapOutOfMemoryErrorTest.java:25)
ERROR: JDWP Unable to get JNI 1.2 environment, jvm->GetEnv() return code = -2
JDWP exit error AGENT_ERROR_NO_JNI_ENV(183):  [util.c:840]

解决方案

  1. 通过-XX:-UseGCOverheadLimit参数来禁用这个检查，但是并不能从根本上来解决内存溢出的问题，最后还是会报出java.lang.OutOfMemoryError: Java heap space异常；
  2. 调整JVM内存大小（-Xmx与-Xms）；

虚拟机栈和本地方法栈溢出

  • 如果线程请求的栈深度大于虚拟机所允许的最大深度，将抛出StackOverflowError异常。
  • 如果虚拟机在扩展栈时无法申请到足够的内存空间，则抛出OutOfMemoryError异常。

这里把异常分成两种情况，看似更加严谨，但却存在着一些互相重叠的地方：当栈空间无法继续分配时，到底是内存太小，还是已使用的栈空间太大，其本质上只是对同一件事情的两种描述而已。

StackOverflowError

出现StackOverflowError异常的主要原因有两点：

  • 单个线程请求的栈深度大于虚拟机所允许的最大深度
  • 创建的线程过多

单个线程请求的栈深度过大

单个线程请求的栈深度大于虚拟机所允许的最大深度，主要表现有以下几点：

  1. 存在递归调用
  2. 存在循环依赖调用
  3. 方法调用链路很深，比如使用装饰器模式的时候，对已经装饰后的对象再进行装饰

异常信息java.lang.StackOverflowError。

装饰器示例：

Collections.unmodifiableList(
        Collections.unmodifiableList(
                Collections.unmodifiableList(
                        Collections.unmodifiableList(
                                Collections.unmodifiableList(
                                                        ...)))))));

递归示例：

/**
 * java 虚拟机栈和本地方法栈内存溢出测试
 * <p>
 * VM Args: -Xss128k
 *
 * @author yuhao.wang3
 * @since 2019/11/30 17:09
 */
public class StackOverflowErrorErrorTest {
    private int stackLength = 0;

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

    public static void main(String[] args) {
        StackOverflowErrorErrorTest sof = new StackOverflowErrorErrorTest();
        try {
            sof.stackLeak();
        } catch (Exception e) {
            System.out.println(sof.stackLength);
            e.printStackTrace();
        }
    }
}

运行结果：

stackLength::1372
java.lang.StackOverflowError
	at com.xiaolyuh.StackOverflowErrorErrorTest.stackLeak(StackOverflowErrorErrorTest.java:16)
	at com.xiaolyuh.StackOverflowErrorErrorTest.stackLeak(StackOverflowErrorErrorTest.java:16)
	at com.xiaolyuh.StackOverflowErrorErrorTest.stackLeak(StackOverflowErrorErrorTest.java:16)
...

当增大栈空间的时候我们就会发现，递归深度会增加，修改栈空间-Xss1m，然后运行程序，运行结果如下：

stackLength::20641
java.lang.StackOverflowError
	at com.xiaolyuh.StackOverflowErrorErrorTest.stackLeak(StackOverflowErrorErrorTest.java:16)
	at com.xiaolyuh.StackOverflowErrorErrorTest.stackLeak(StackOverflowErrorErrorTest.java:16)
...

修改递归方法的参数列表后递归深度急剧减少：

public void stackLeak(String ags1, String ags2, String ags3) {
    stackLength++;
    stackLeak(ags1, ags2, ags3);
}

运行结果如下：

stackLength::13154
java.lang.StackOverflowError
	at com.xiaolyuh.StackOverflowErrorErrorTest.stackLeak(StackOverflowErrorErrorTest.java:16)
	at com.xiaolyuh.StackOverflowErrorErrorTest.stackLeak(StackOverflowErrorErrorTest.java:16)
...

由此可见影响递归的深度因素有：

  1. 单个线程的栈空间大小（-Xss）
  2. 局部变量表的大小

单个线程请求的栈深度超过内存限制导致的栈内存溢出，一般是由于非正确的编码导致的。从上面的示例我们可以看出，当栈空间在-Xss128k的时候，调用层级都在1000以上，一般情况下方法的调用是达不到这个深度的。如果方法调用的深度确实有这么大，那么我们可以通过-Xss配置来增大栈空间大小。

创建的线程过多

不断地建立线程也可能导致栈内存溢出，因为我们机器的总内存是有限制的，所以虚拟机栈和本地方法栈对应的内存也是有最大限制的。如果单个线程的栈空间越大，那么整个应用允许创建的线程数就越少。异常信息java.lang.OutOfMemoryError: unable to create new native thread。

虚拟机栈和本地方法栈内存 ≈ 操作系统内存限制 - 最大堆容量(Xmx) - 最大方法区容量(MaxPermSize)

过多创建线程示例：

/**
 * java 虚拟机栈和本地方法栈内存溢出测试
 * <p>
 * 创建线程过多导致内存溢出异常
 * <p>
 * VM Args: -verbose:gc -Xss20M -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=D:\dump
 *
 * @author yuhao.wang3
 * @since 2019/11/30 17:09
 */
public class StackOutOfMemoryErrorTest {
    private static int threadCount;

    public static void main(String[] args) throws Throwable {
        try {
            while (true) {
                threadCount++;
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        try {
                            Thread.sleep(1000 * 60 * 10);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }).start();
            }
        } catch (Throwable e) {
            e.printStackTrace();
            throw e;
        } finally {
            System.out.println("threadCount=" + threadCount);
        }
    }
}

Java的线程是映射到操作系统的内核线程上，因此上述代码执行时有较大的风险，可能会导致操作系统假死。

运行结果：

java.lang.OutOfMemoryError: unable to create new native thread
	at java.lang.Thread.start0(Native Method)
	at java.lang.Thread.start(Thread.java:717)
	at StackOutOfMemoryErrorTest.main(StackOutOfMemoryErrorTest.java:17)
threadCount=4131
Exception in thread "main" java.lang.OutOfMemoryError: unable to create new native thread
	at java.lang.Thread.start0(Native Method)
	at java.lang.Thread.start(Thread.java:717)
	at StackOutOfMemoryErrorTest.main(StackOutOfMemoryErrorTest.java:17)

需要重新上述异常，最好是在32位机器上，因为我在64位机器没有重现。

在有限的内存空间里面，当我们需要创建更多的线程的时候，我们可以减少单个线程的栈空间大小。

元数据区域的内存溢出

元数据区域或方法区是用于存放Class的相关信息，如类名、访问修饰符、常量池、字段描述、方法描述等。我们可以通过在运行时产生大量的类去填满方法区，直到溢出，如：代理的使用(CGlib)、大量JSP或动态产生JSP文件的应用（JSP第一次运行时需要编译为Java类）、基于OSGi的应用（即使是同一个类文件，被不同的加载器加载也会视为不同的类）等。

/**
 * java 元数据区域/方法区的内存溢出
 * <p>
 * VM Args JDK 1.6: set JAVA_OPTS=-verbose:gc -XX:PermSize=10m -XX:MaxPermSize=10m -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=D:\dump
 * <p>
 * VM Args JDK 1.8: set JAVA_OPTS=-verbose:gc -Xmx20m -XX:MetaspaceSize=5m -XX:MaxMetaspaceSize=5m -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=D:\dump
 *
 * @author yuhao.wang3
 * @since 2019/11/30 17:09
 */
public class MethodAreaOutOfMemoryErrorTest {

    static class MethodAreaOOM {
    }

    public static void main(String[] args) {
        while (true) {
            Enhancer enhancer = new Enhancer();
            enhancer.setSuperclass(MethodAreaOOM.class);
            enhancer.setCallback(new MethodInterceptor() {
                @Override
                public Object intercept(Object obj, Method method, Object[] params, MethodProxy proxy) throws Throwable {
                    return proxy.invokeSuper(obj, params);
                }
            });
            enhancer.create();
        }
    }
}

运行结果：

[GC (Last ditch collection)  1283K->1283K(16384K), 0.0002585 secs]
[Full GC (Last ditch collection)  1283K->1226K(19968K), 0.0075856 secs]
java.lang.OutOfMemoryError: Metaspace
Dumping heap to D:\dump\java_pid18364.hprof ...
Heap dump file created [2479477 bytes in 0.015 secs]
[GC (Metadata GC Threshold)  1450K->1354K(19968K), 0.0003906 secs]
[Full GC (Metadata GC Threshold)  1354K->976K(19968K), 0.0073752 secs]
[GC (Last ditch collection)  976K->976K(19968K), 0.0002921 secs]
[Full GC (Last ditch collection)  976K->973K(19968K), 0.0045243 secs]
Exception in thread "main" java.lang.OutOfMemoryError: Metaspace
	at java.lang.ClassLoader.defineClass1(Native Method)
	at java.lang.ClassLoader.defineClass(ClassLoader.java:763)
	at java.security.SecureClassLoader.defineClass(SecureClassLoader.java:142)
	at java.net.URLClassLoader.defineClass(URLClassLoader.java:467)
	at java.net.URLClassLoader.access$100(URLClassLoader.java:73)
	at java.net.URLClassLoader$1.run(URLClassLoader.java:368)
	at java.net.URLClassLoader$1.run(URLClassLoader.java:362)
	at java.security.AccessController.doPrivileged(Native Method)
	at java.net.URLClassLoader.findClass(URLClassLoader.java:361)
	at java.lang.ClassLoader.loadClass(ClassLoader.java:424)
	at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:331)
	at java.lang.ClassLoader.loadClass(ClassLoader.java:357)
	at org.springframework.cglib.core.internal.LoadingCache.createEntry(LoadingCache.java:52)
	at org.springframework.cglib.core.internal.LoadingCache.get(LoadingCache.java:34)
	at org.springframework.cglib.core.AbstractClassGenerator$ClassLoaderData.get(AbstractClassGenerator.java:116)
	at org.springframework.cglib.core.AbstractClassGenerator.create(AbstractClassGenerator.java:291)
	at org.springframework.cglib.core.KeyFactory$Generator.create(KeyFactory.java:221)
	at org.springframework.cglib.core.KeyFactory.create(KeyFactory.java:174)
	at org.springframework.cglib.core.KeyFactory.create(KeyFactory.java:153)
	at org.springframework.cglib.proxy.Enhancer.<clinit>(Enhancer.java:73)
	at com.xiaolyuh.MethodAreaOutOfMemoryErrorTest.main(MethodAreaOutOfMemoryErrorTest.java:26)

运行时常量池的内存溢出

String.intern()是一个Native方法，它的作用是：如果字符串常量池中已经包含一个等于此String对象的字符串，则返回代表池中这个字符串的String对象；否则，将此String对象包含的字符串添加到常量池中，并且返回此String对象的引用。

在JDK 1.6的时候，运行时常量池是在方法区中，所以直接限制了方法区中大小就可以模拟出运行池常量池的内存溢出。

/**
 * java 方法区和运行时常量池溢出
 * <p>
 * VM Args JDK 1.6: set JAVA_OPTS=-verbose:gc -XX:PermSize10 -XX:MaxPermSize10m -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=D:\dump
 *
 * @author yuhao.wang3
 * @since 2019/11/30 17:09
 */
public class RuntimeConstantOutOfMemoryErrorTest {

    public static void main(String[] args) {
        // 使用List保存着常量池的引用，避免Full GC 回收常量池行为
        List<String> list = new ArrayList<>();
        for (int i = 0; ; i++) {
            list.add(String.valueOf(i).intern());
        }
    }
}

运行结果：

Exception in thread "main" java.lang.OutOfMemoryError: PermGen space
    at java.lang.String.intern(Native Method)
    at RuntimeConstantOutOfMemoryErrorTest.main(RuntimeConstantOutOfMemoryErrorTest.java:18)

直接内存溢出

DirectMemory容量可通过-XX:MaxDirectMemorySize指定，如果不指定，则默认与Java堆最大值（-Xmx指定）一样。

/**
 * java 直接内存溢出
 * <p>
 * VM Args JDK 1.6: set JAVA_OPTS=-verbose:gc -Xms20m -XX:MaxDirectMemorySize=10m -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=D:\dump
 *
 * @author yuhao.wang3
 * @since 2019/11/30 17:09
 */
public class DirectMemoryOutOfMemoryErrorTest {

    public static void main(String[] args) throws IllegalAccessException {
        int _1M = 1024 * 1024;
        Field unsafeField = Unsafe.class.getDeclaredFields()[0];
        unsafeField.setAccessible(true);
        Unsafe unsafe = (Unsafe) unsafeField.get(null);
        while (true) {
            unsafe.allocateMemory(_1M);
        }
    }
}

运行结果：

Exception in thread "main" java.lang.OutOfMemoryError
	at sun.misc.Unsafe.allocateMemory(Native Method)
	at com.xiaolyuh.DirectMemoryOutOfMemoryErrorTest.main(DirectMemoryOutOfMemoryErrorTest.java:23)

由DirectMemory导致的内存溢出，一个明显的特征是在Heap Dump文件中不会看见明显的异常，如果读者发现OOM之后Dump文件很小，而程序中又直接或间接使用了NIO，那就可以考虑检查一下是不是这方面的原因。

解决方案

通过-XX:MaxDirectMemorySize指定直接内存大小。

源码

https://github.com/wyh-spring-ecosystem-student/spring-boot-student/tree/releases

spring-boot-student-jvm工程

参考

《深入理解JAVA虚拟机》

JDK下载地址

JDK 下载地址

xiaolyuh123
关注
专栏目录
2024年Java最全【深入理解JVM】模拟内存溢出及排查分析，大厂直通车
2401_84002294的博客
05-05 774
这份《“java高分面试指南”-25分类227页1000+题50w+字解析》同样可分享给有需要的朋友，感兴趣的伙伴们可挑战一下自我，在不看答案解析的情况，测试测试自己的解题水平，这样也能达到事半功倍的效果！（好东西要大家一起看才香）本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录需要这份系统化的资料的朋友，可以点击这里获取6、代码走查和分析一、内存溢出的原因。
[JVM教程与调优] 了解JVM 堆内存溢出以及非堆内存溢出
2401_83916030的博客
04-18 833
从图中我们可以看到，JVM的内存结构分为两大块。一块叫，一块叫。堆区又分为两大块，一块，一块叫。区又分为区和区。区我们又分为S0与S1。可以结合下图进行理解JVM堆区非堆区呢，是属于我们操作系统的本地内存。它是独立于我们堆区之外的。它在里面有一个新的名字，叫Metaspace。Metaspace里面还包含几个块，其中有一块就是CCS,还有一块是CodeCache。当然，在我们的Metaspace中还包含很多其他块，这里就不做扩展了。接下来，我们来通过实战，来更加深入的理解JVM。
关于内存溢出的理解
QIyusama的博客
05-30 180
关于内存溢出理解： 例： int转为byte int的内存位数为32位 byte的内存位数为8位 int 128二进制为0000 0000 0000 0000 0000 0000 1000 0000 byte 128二进制为1000 0000 当int转为byte时 Int前面多出的数字会消掉变为1000 0000 此时1000 0000为byte的原码 1是符号位（进制中0为正 1为负） 所以byte的反码就是1111 1111 计算它的补码 除去符号位不算 根据二进...
理解内存溢出
坞村野人
08-07 589
译者：不悔 QQ：845486067 原文：https://docs.oracle.com/javase/8/docs/technotes/guides/troubleshoot/memleaks002.html 内存泄漏的常见现象就是java.lang.OutOfMemoryError异常。这个异常常见抛出的情况为：当需要分配对象的时候，堆空间不足。在这种情况下，垃圾收集器无法获取一个有效的...
jvm的元空间溢出案例及解决办法，给出详细例子
最新发布
weixin_39304656的博客
09-26 508
元空间溢出频繁动态生成类：例如使用大量代理类（如 Spring AOP 或 CGLIB 生成的动态代理）。类加载器泄露：类加载器无法被回收，导致其加载的类无法被卸载。超过元空间大小限制：元空间的最大大小由 JVM 参数控制，若内存不足以容纳更多的类元数据，会导致错误。增加元空间大小：调整 JVM 参数来增加元空间的最大值。避免类加载器泄漏：检查类加载器的使用，确保类加载器可以被正确回收。减少动态类生成：优化动态代理代码，避免频繁地生成不必要的类。监控元空间使用。
java内存溢出实战
weixin_30273501的博客
05-19 111
通过设置-XX:+HeapDumpOnOutOfMemoryError 自动生成dump文件，进行分析内存溢出原因 1、堆溢出堆溢出原因莫过于对象太多导致。 错误：java.lang.OutOfMemoryError: Java heap space 2.栈溢出 如果线程请求的栈深度大于虚拟机所允许的最大深度，将抛出StackOverflowError 如果虚拟机在扩展栈时无法申请...
java内存溢出实战_java内存溢出实战
weixin_33594662的博客
02-26 177
通过设置-XX:+HeapDumpOnOutOfMemoryError 自动生成dump文件，进行分析内存溢出原因1、堆溢出堆溢出原因莫过于对象太多导致。错误：java.lang.OutOfMemoryError: Java heap space2.栈溢出如果线程请求的栈深度大于虚拟机所允许的最大深度，将抛出StackOverflowError如果虚拟机在扩展栈时无法申请到足够的内存空间，将抛出O...
java实战内存溢出
zdb_love_zy的博客
11-11 212
内存溢出问题 在实际开发过程中，有可能会遇到内存溢出的错误，如java.lang.OutOfMemoryError: Java heap space，也就是堆内存溢出，这个时候就得排查到底是什么导致了内存溢出，一般情况下，有以下两种情况 内存预分配空间不足 内存泄露 内存分配空间不足，说明启动程序之前对程序整体的空间没有一个很好的预测导致内存空间太小，但是笔者认为这种情况很少见，所以更多的情况...
JVM实战-对象访问与内存溢出异常解析
05-07
通过本实验，旨在深入理解JVM内存管理机制以及各种内存区域的特点，并通过具体的编程实践来触发并分析这些异常，进而提升对Java应用程序性能调优和故障排查的能力。 #### 实验目标 1. **理解内存区域与内存区域...
理论与实践结合 解密JVM-day02.rar
06-21
7. **JVM内存溢出** 内存溢出是JVM运行中常见的问题，如堆溢出（Heap Overflow）、栈溢出（Stack Overflow）等。理解不同类型的溢出以及如何处理它们是JVM实战中的重要技能。 8. **JVM字节码指令** 学习JVM字节码...
jvm-demo1.zip
09-10
《深入理解JVM调优：基于jvm-demo1.zip实战解析》 在Java开发中，JVM（Java Virtual Machine）的性能优化是一项至关重要的任务，它直接影响到应用程序的运行效率和稳定性。`jvm-demo1.zip`这个压缩包提供了一些实战...
【Java虚拟机】内存溢出实战
不万能奥赛罗的博客
09-14 295
在Java虚拟机规范的描述中，除了程序计数器外，虚拟机内存的其他几个运行时区域都有发生OutOfMemoryError（下文称OOM）异常的可能，本节将通过若干实例来验证异常发生的场景。     测试异常需要设置虚拟机的启动参数，以MyEclipse工具为例，修改如下：Run——>Run Configurations；（修改的参数在代码顶部注释中，这些参数将对实验的结果有直接影响） J
java内存溢出实战_JVM内存溢出分析-实战JVM（二）
weixin_39791386的博客
03-08 119
JVM规范规定，除了程序计数器，虚拟机其他内存区域均会发生内存溢出的可能，OutOfMemoryError(OOM)本文目的：1、通过代码人为造成OOM，让大家跟了解JVM运行时各区存储的内容。2、通过demo让大家实际开发过程中，能够根据异常判断是那个内存区域发生的溢出，3、让大家了解到什么样的代码会产生OOM，开发中能够尽量规避。前提：先和大家介绍一下eclipse如何设置JVM参数，Xms ...
对内存溢出和内存泄漏的理解
weixin_44877390的博客
02-06 262
内存溢出 内存溢出是指无法申请到足够的内存空间。 内存泄漏 内存泄漏是指无法释放掉已经申请的内存。
java内存溢出实战_JVM内存溢出分析实战：手把手教你如何分析！
weixin_39630048的博客
02-26 160
谈谈内存溢出与内存泄漏的关系？内存泄漏是申请了内存用完了不释放，内存溢出是申请内存时，没有足够的内存可以使用。内存泄漏最终会导致内存溢出，也可以说内存泄漏是内存溢出的一种。谈谈引起内存溢出的原因有哪些？1、内存中加载的数据量过于庞大，如一次从数据库取出过多数据2、集合类中有对对象的引用，使用完未清空，使得JVM不能回收3、代码中存在死循环或循环产生过多重复的对象实体4、使用的第三方软件中的BUG5...
个人对内存泄漏和内存溢出的理解
baidu_36930024的博客
02-08 1046
内存泄漏： 从语义上讲就是内存外露了的部分，跟伤口一样，那么就被细菌覆盖，我们要及时把它治愈，就应该去除细菌贴上邦迪，把伤口藏起来，就相当于释放内存，让坏虫子走开，不让它们占有不该占有的东西。 编完了，来看下实际解释：memory leak，是指程序在申请内存后，无法释放已申请的内存空间，一次内存泄露危害可以忽略，但内存泄露堆积后果很严重，无论多少内存,迟早会被占光。
Java内存区域与内存溢出
weixin_34258078的博客
03-29 110
前言 最近在读周志明老师的《深入理解Java虚拟机》,感觉一下换了一个角度来看待Java代码，有必要整理一些内容，更清楚实际的流程，这一篇就记录下Java内存区域与相关的一些内存溢出的异常。 内存区域 Java虚拟机在执行Java程序的过程会把它管理的内存划分为各个不同的区域，这些区域都有着各自的生命周期，总的来说Java虚拟机管理的内存...
JVM(7)内存溢出问题（工作中常用、面试也重要的知识点）
冯冬冬的博客
12-11 535
内存溢出是指应用系统中存在无法回收的内存或使用的内存过多，最终使得程序运行要用到的内存大于虚拟机能提供的最大内存。这篇文章整理自《深入理解java虚拟机》。因为内存溢出问题不仅是工作中的一个重要方面，而且面试中也是经常问。 一、内存溢出原因 内存溢出就是内存不够，引起内存溢出的原因有很多种，常见的有以下几种： 1、内存中加载的数据量过于庞大，如一次从数据库取出过多数据； 2、集合类中有对对象的引用...
深入解析：JVM内存结构探索与实战应用
本文是一篇关于深入探究Java虚拟机（JVM）内存结构的博客文章，作者试图用更生动、易理解的方式呈现枯燥的JVM内存知识。文章旨在帮助读者更好地理解和掌握JVM内存管理机制，从而在面试中提升竞争力，以及提高编程...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值