AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

结合代码和内存变化图一步步弄懂JVM的FullGC

2023-03-06 412
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
日志服务 SLS，月写入数据量 50GB 1个月
简介： 一步步结合代码去验证jvm的内存变化，并画出内存变化的示意图，从而探索出jvm fullGC的原因。

1.年轻代存活的对象太多,老年代了放不下

01.示例代码

public class DemoTest1 {
    public static void main(String[] args) {
        byte[] array1 = new byte[4 * 1024 * 1024];
        array1 = null;

        byte[] array2 = new byte[2 * 1024 * 1024];
        byte[] array3 = new byte[2 * 1024 * 1024];
        byte[] array4 = new byte[2 * 1024 * 1024];
        byte[] array5 = new byte[128 * 1024];

        byte[] array6 = new byte[2 * 1024 * 1024];

    }

02.启动JVM参数

-XX:NewSize=10485760 -XX:MaxNewSize=10485760 -XX:InitialHeapSize=20971520 -XX:MaxHeapSize=20971520 -XX:SurvivorRatio=8  -XX:MaxTenuringThreshold=15 -XX:PretenureSizeThreshold=3145728 -XX:+UseParNewGC -XX:+UseConcMarkSweepGC -XX:+PrintGCDetails -XX:+PrintGCTimeStamps -Xloggc:gc.log

其中，参数-XX:PretenureSizeThreshold,参数要设置大对象阈值为3MB，也就是超过3MB，就直接进入老年代。

大对象大小是3MB。一旦对象大小超过3MB，不会进入新生代，直接进入老年代。

启动命令：

java  -jar -XX:NewSize=10485760 -XX:MaxNewSize=10485760 -XX:InitialHeapSize=20971520 -XX:MaxHeapSize=20971520 -XX:SurvivorRatio=8  -XX:MaxTenuringThre
shold=15 -XX:PretenureSizeThreshold=3145728 -XX:+UseParNewGC -XX:+UseConcMarkSweepGC -XX:+PrintGCDetails -XX:+PrintGCTimeStamps -Xloggc:gc.log jvm-demo.jar

03.GC日志

启动之后就得到如下GC日志:

Java HotSpot(TM) 64-Bit Server VM (25.151-b12) for windows-amd64 JRE (1.8.0_151-b12), built on Sep  5 2017 19:33:46 by "java_re" with MS VC++ 10.0 (VS2010)
Memory: 4k page, physical 16703268k(7458748k free), swap 23781156k(9784196k free)
CommandLine flags: -XX:InitialHeapSize=20971520 -XX:MaxHeapSize=20971520 -XX:MaxNewSize=10485760 -XX:MaxTenuringThreshold=15 -XX:NewSize=10485760 -XX:OldPLABSize=16 -XX:PretenureSizeThreshold=3145728 -XX:+PrintGC -XX:+PrintGCDetails -XX:+PrintGCTimeStamps -XX:SurvivorRatio=8 -XX:+UseCompressedClassPointers -XX:+UseCompressedOops -XX:+UseConcMarkSweepGC -XX:-UseLargePagesIndividualAllocation -XX:+UseParNewGC 
0.174: [GC (Allocation Failure) 0.174: [ParNew (promotion failed): 7457K->8328K(9216K), 0.0046949 secs]
0.179: [CMS: 8194K->6962K(10240K), 0.0033396 secs] 11553K->6962K(19456K), [Metaspace: 2970K->2970K(1056768K)], 0.0089224 secs] [Times: user=0.00 sys=0.00, real=0.01 secs] 
Heap
 par new generation   total 9216K, used 2130K [0x00000000fec00000, 0x00000000ff600000, 0x00000000ff600000)
  eden space 8192K,  26% used [0x00000000fec00000, 0x00000000fee14930, 0x00000000ff400000)
  from space 1024K,   0% used [0x00000000ff500000, 0x00000000ff500000, 0x00000000ff600000)
  to   space 1024K,   0% used [0x00000000ff400000, 0x00000000ff400000, 0x00000000ff500000)
 concurrent mark-sweep generation total 10240K, used 6962K [0x00000000ff600000, 0x0000000100000000, 0x0000000100000000)
 Metaspace       used 2976K, capacity 4486K, committed 4864K, reserved 1056768K
  class space    used 330K, capacity 386K, committed 512K, reserved 1048576K

04.分析GC日志

先看如下代码：

 byte[] array1 = new byte[4 * 1024 * 1024];
        array1 = null;

这行代码直接分配了一个4MB的大对象，此时这个对象会直接进入老年代，接着array1不再引用这个对象。

此时内存分配如下：

1714d334d0287653~tplv-t2oaga2asx-image.image

紧接着就是如下代码

byte[] array2 = new byte[2 * 1024 * 1024];
        byte[] array3 = new byte[2 * 1024 * 1024];
        byte[] array4 = new byte[2 * 1024 * 1024];
        byte[] array5 = new byte[128 * 1024];

连续分配了4个数组，其中3个是2MB的数组，1个是128KB的数组，如下图所示，全部会进入Eden区域中。

1714d334d5fe9940~tplv-t2oaga2asx-image.image

接着会执行如下代码：byte[] array6 = new byte[2 * 1024 * 1024];。此时还能放得下2MB的对象吗？

不可能了，因为Eden区已经放不下了。因此此时会直接触发一次Young GC。

我们看下面的GC日志：

0.174: [GC (Allocation Failure) 0.174: [ParNew (promotion failed): 7457K->8328K(9216K), 0.0046949 secs]

这行日志显示了，Eden区原来是有7000多KB的对象，但是回收之后发现一个都回收不掉，因为上述几个数组都被变量引用了。

所以此时，一定会直接把这些对象放入到老年代里去，但是此时老年代里已经有一个4MB的数组了，还能放的下3个2MB的数组和1个128KB的数组吗？

明显是不行的，此时一定会超过老年代的10MB大小。

所以此时看gc日志：

0.179: [CMS: 8194K->6962K(10240K), 0.0033396 secs] 11553K->6962K(19456K), [Metaspace: 2970K->2970K(1056768K)], 0.0089224 secs] [Times: user=0.00 sys=0.00, real=0.01 secs]

此时执行了CMS垃圾回收器的Full GC，Full GC其实就是会对老年代进行Old GC，同时一般会跟一次Young GC关联，还会触发一次元数据区（永久代）的GC。

在CMS Full GC之前，就已经触发过Young GC了，此时可以看到此时Young GC就已经有了，接着就是执行针对老年代的Old GC，也就是如下日志：

CMS: 8194K->6962K(10240K), 0.0033396 secs

这里看到老年代从8MB左右的对象占用，变成了6MB左右的对象占用，这是怎么个过程呢？

很简单，一定是在Young GC之后，先把2个2MB的数组放入了老年代，如下图。

1714d334db4b93cd~tplv-t2oaga2asx-image.image

此时要继续放1个2MB的数组和1个128KB的数组到老年代，一定会放不下，所以此时就会触发CMS的Full GC。

然后此时就会回收掉其中的一个4MB的数组，因为他已经没人引用了，如下图所示。

1714d33522f05bd3~tplv-t2oaga2asx-image.image

所以再看CMS的垃圾回收日志：CMS: 8194K->6962K(10240K), 0.0033396 secs，他是从回收前的8MB变成了6MB，就是上图所示。

最后在CMS Full GC执行完毕之后，其实年轻代的对象都进入了老年代，此时最后一行代码要在年轻代分配2MB的数组就可以成功了，如下图。

1714d334d436fd46~tplv-t2oaga2asx-image.image

05.总结

这是一个触发老年代GC的案例，就是年轻代存活的对象太多放不下老年代了，此时就会触发CMS的Full GC。

2.老年代可用空间小于了历次Young GC后升入老年代的对象的平均大小

01.示例代码

public class DemoTest1 {
    public static void main(String[] args) {
        byte[] array1 = new byte[1 * 1024 * 1024];
        array1 = null;
        byte[] array2 = new byte[1 * 1024 * 1024];
        array2 = null;
        byte[] array3 = new byte[1 * 1024 * 1024];
        array3 = null;
        byte[] array4 = new byte[1 * 1024 * 1024];//触发YGC 1MB    1

        array1 = new byte[1 * 1024 * 1024];
        array1 = null;
        array2 = new byte[1 * 1024 * 1024];
        array2 = null;
        array3 = new byte[1 * 1024 * 1024];//触发YGC   Y 1MB O 1MB  2
        array3 = null;

        byte[] array5 = new byte[1 * 1024 * 1024];// Y 2MB  O 1MB
        array1 = new byte[1 * 1024 * 1024];// Y 3MB
        array1 = null;
        array2 = new byte[1 * 1024 * 1024];// Y 1MB  O 2MB YGC   3
        
        array2 = null;
        array3 = new byte[1 * 1024 * 1024];//Y 2MB  O 2MB
        array3 = null;
        byte[] array6 = new byte[1 * 1024 * 1024];//Y 3MB  O 2MB
        array1 = new byte[1 * 1024 * 1024];//Y 1MB  O 3MB YGC  4
        
        array1 = null;
        array2 = new byte[1 * 1024 * 1024];//Y 2MB
        array2 = null;
        array3 = new byte[1 * 1024 * 1024];//Y 3MB
        array3 = null;
        byte[] array7 = new byte[1 * 1024 * 1024];//YGC  5

    }
}

02.启动JVM参数

-XX:NewSize=5M -XX:MaxNewSize=5M -XX:InitialHeapSize=10M -XX:MaxHeapSize=10M -XX:SurvivorRatio=8  -XX:MaxTenuringThreshold=15 -XX:PretenureSizeThreshold=2M -XX:+UseParNewGC -XX:+UseConcMarkSweepGC -XX:+PrintGCDetails -XX:+PrintGCTimeStamps -Xloggc:gc.log

其中，参数-XX:PretenureSizeThreshold,参数要设置大对象阈值为2MB，也就是超过2MB，就直接进入老年代。

大对象大小是3MB。一旦对象大小超过3MB，不会进入新生代，直接进入老年代。

启动命令：

java  -jar -XX:NewSize=5M -XX:MaxNewSize=5M -XX:InitialHeapSize=10M -XX:MaxHeapSize=10M -XX:SurvivorRatio=8  -XX:MaxTenuringThreshold=15 -XX:PretenureSizeThreshold=2M -XX:+UseParNewGC -XX:+UseConcMarkSweepGC -XX:+PrintGCDetails -XX:+PrintGCTimeStamps -Xloggc:gc.log jvm-demo.jar

03.GC日志

启动之后就得到如下GC日志:

老年代

年轻代

Java HotSpot(TM) 64-Bit Server VM (25.151-b12) for windows-amd64 JRE (1.8.0_151-b12), built on Sep  5 2017 19:33:46 by "java_re" with MS VC++ 10.0 (VS2010)
Memory: 4k page, physical 16703268k(7221016k free), swap 23781156k(8613656k free)
CommandLine flags: -XX:InitialHeapSize=10485760 -XX:MaxHeapSize=10485760 -XX:MaxNewSize=5242880 -XX:MaxTenuringThreshold=15 -XX:NewSize=5242880 -XX:OldPLABSize=16 -XX:PretenureSizeThreshold=2097152 -XX:+PrintGC -XX:+PrintGCDetails -XX:+PrintGCTimeStamps -XX:SurvivorRatio=8 -XX:+UseCompressedClassPointers -XX:+UseCompressedOops -XX:+UseConcMarkSweepGC -XX:-UseLargePagesIndividualAllocation -XX:+UseParNewGC 
0.121: [GC (Allocation Failure) 0.121: [ParNew: 3155K->512K(4608K), 0.0041165 secs] 3155K->766K(9728K), 0.0042644 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
0.125: [GC (Allocation Failure) 0.125: [ParNew: 3663K->0K(4608K), 0.0016667 secs] 3917K->1732K(9728K), 0.0017448 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
0.127: [GC (Allocation Failure) 0.127: [ParNew: 3142K->0K(4608K), 0.0013221 secs] 4875K->2756K(9728K), 0.0013592 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
0.129: [GC (CMS Initial Mark) [1 CMS-initial-mark: 2756K(5120K)] 4878K(9728K), 0.0004498 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
0.129: [CMS-concurrent-mark-start]
0.130: [GC (Allocation Failure) 0.130: [ParNew: 3146K->0K(4608K), 0.0005869 secs] 5902K->2756K(9728K), 0.0006362 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
0.131: [GC (Allocation Failure) 0.131: [ParNew: 3148K->0K(4608K), 0.0007974 secs] 5904K->3780K(9728K), 0.0008262 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
Heap
 par new generation   total 4608K, used 2207K [0x00000000ff600000, 0x00000000ffb00000, 0x00000000ffb00000)
  eden space 4096K,  53% used [0x00000000ff600000, 0x00000000ff827f38, 0x00000000ffa00000)
  from space 512K,   0% used [0x00000000ffa80000, 0x00000000ffa80000, 0x00000000ffb00000)
  to   space 512K,   0% used [0x00000000ffa00000, 0x00000000ffa00000, 0x00000000ffa80000)
 concurrent mark-sweep generation total 5120K, used 3780K [0x00000000ffb00000, 0x0000000100000000, 0x0000000100000000)
 Metaspace       used 2976K, capacity 4486K, committed 4864K, reserved 1056768K
  class space    used 330K, capacity 386K, committed 512K, reserved 1048576K

04.分析GC日志

(1).代码块1

先看如下代码：

  byte[] array1 = new byte[1 * 1024 * 1024];
  array1 = null;
  byte[] array2 = new byte[1 * 1024 * 1024];
  array2 = null;
  byte[] array3 = new byte[1 * 1024 * 1024];
  array3 = null;
  byte[] array4 = new byte[1 * 1024 * 1024];

这段代码直接分配了4个1MB的数组，并且在第4个数组的时候，会因为新生代内存不足触发YGC。

此时内存分配如下：

1714d334ea2345b2~tplv-t2oaga2asx-image.image

对应如下GC日志：

0.121: [GC (Allocation Failure) 0.121: [ParNew: 3155K->512K(4608K), 0.0041165 secs] 3155K->766K(9728K), 0.0042644 secs] [Times: user=0.00 sys=0.00, real=0.00 secs]

此时，可以看到新生代就只剩512K的对象，这个奇怪的512KB的对象进入Survivor From区。

那么大小为1MB的数组对象去哪里呢？肯定不是这个奇怪的512KB的对象。

这1MB的数组首先肯定是准备进入Survivor From区，可是，在我们设置的JVM参数下，只有0.5MB，明显是不够分配的。根据JVM YoungGC的规则,Survivor区放不下GC之后存活的对象，直接进入老年代。

所以，1MB的数组对象是直接进入到老年代了。

此时，内存分配如下：

1714d3362aa43a2a~tplv-t2oaga2asx-image.image

(2).代码块2

紧接这就是这块代码：

 array1 = new byte[1 * 1024 * 1024];
 array1 = null;
 array2 = new byte[1 * 1024 * 1024];
 array2 = null;
 array3 = new byte[1 * 1024 * 1024];

这里再次创建了3个1MB的数组对象，并且会触发一次YoungGC；

对应 GC日志如下：

0.125: [GC (Allocation Failure) 0.125: [ParNew: 3663K->0K(4608K), 0.0016667 secs] 3917K->1732K(9728K), 0.0017448 secs] [Times: user=0.00 sys=0.00, real=0.00 secs]

此时，Young GC之后，新生代变成0KB，那么存活的大小为1MB的数组对象去哪里呢？

这1MB的数组首先肯定是准备进入Survivor From区，可是，在我们设置的JVM参数下，只有0.5MB，明显是不够分配的。根据JVM YoungGC的规则,Survivor区放不下GC之后存活的对象，直接进入老年代。

所以，1MB的数组对象是直接进入到老年代了。

之前看到的未知的对象512KB也进入到老年代，此时内存分配如下：

1714d33675a8e01c~tplv-t2oaga2asx-image.image

(3).代码块3
array3 = null;
byte[] array5 = new byte[1 * 1024 * 1024];
array1 = new byte[1 * 1024 * 1024];
array1 = null;
array2 = new byte[1 * 1024 * 1024];

这里再次创建了3个1MB的数组对象，并且会触发一次YoungGC；

对应的GC日志如下：

0.127: [GC (Allocation Failure) 0.127: [ParNew: 3142K->0K(4608K), 0.0013221 secs] 4875K->2756K(9728K), 0.0013592 secs] [Times: user=0.00 sys=0.00, real=0.00 secs]

此时内存分配如下：

1714d3363298497c~tplv-t2oaga2asx-image.image

(4).代码块4
array2 = null;
array3 = new byte[1 * 1024 * 1024];//Y 2MB  O 2MB
array3 = null;
byte[] array6 = new byte[1 * 1024 * 1024];
array1 = new byte[1 * 1024 * 1024];

这里再次创建了3个1MB的数组对象，并且会触发一次YoungGC；并且在这儿，触发Young GC之前触发了一次CMS的Old GC,触发的条件就是老年代可用空间小于了历次Young GC后升入老年代的对象的平均大小。此时新生代大小变成0KB

对应的GC日志如下：

0.129: [GC (CMS Initial Mark) [1 CMS-initial-mark: 2756K(5120K)] 4878K(9728K), 0.0004498 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
0.129: [CMS-concurrent-mark-start]
0.130: [GC (Allocation Failure) 0.130: [ParNew: 3146K->0K(4608K), 0.0005869 secs] 5902K->2756K(9728K), 0.0006362 secs] [Times: user=0.00 sys=0.00, real=0.00 secs]

此时内存分配如下：

1714d3367c1a0bc9~tplv-t2oaga2asx-image.image

(5).代码块5
array1 = null;
array2 = new byte[1 * 1024 * 1024];//Y 2MB
array2 = null;
array3 = new byte[1 * 1024 * 1024];//Y 3MB
array3 = null;
byte[] array7 = new byte[1 * 1024 * 1024];

此时，再创建3个1MB的数组对象，再次触发一次Young GC，执行完YoungGC，此时新生代大小变成0KB；

对应的GC日志如下：

0.131: [GC (Allocation Failure) 0.131: [ParNew: 3148K->0K(4608K), 0.0007974 secs] 5904K->3780K(9728K), 0.0008262 secs] [Times: user=0.00 sys=0.00, real=0.00 secs]

此时内存分配如下：

1714d3369e58a00b~tplv-t2oaga2asx-image.image

(6).总结

如下GC堆内存日志我们也可以去验证下上面的推测：

此时新生代使用了53%的大小，我们还有一个1MB的数组，可能还存在一些未知对象。

在老年代中使用了大约3MB的空间，应该就是上图中的对象。

Heap
 par new generation   total 4608K, used 2207K [0x00000000ff600000, 0x00000000ffb00000, 0x00000000ffb00000)
  eden space 4096K,  53% used [0x00000000ff600000, 0x00000000ff827f38, 0x00000000ffa00000)
  from space 512K,   0% used [0x00000000ffa80000, 0x00000000ffa80000, 0x00000000ffb00000)
  to   space 512K,   0% used [0x00000000ffa00000, 0x00000000ffa00000, 0x00000000ffa80000)
 concurrent mark-sweep generation total 5120K, used 3780K [0x00000000ffb00000, 0x0000000100000000, 0x0000000100000000)
 Metaspace       used 2976K, capacity 4486K, committed 4864K, reserved 1056768K
  class space    used 330K, capacity 386K, committed 512K, reserved 1048576K

3.几个触发Full GC的条件

第一：是老年代可用内存小于新生代全部对象的大小，如果没开启空间担保参数，会直接触发Full GC，所以一般空间担保参数都会打开；注：jDK1.8之后已经取消了 -XX:-HandlePromotionFailure 机制

第二：是老年代可用内存小于历次新生代GC后进入老年代的平均对象大小，此时会提前Full GC；

第三：是新生代Minor GC后的存活对象大于Survivor，那么就会进入老年代，此时老年代内存不足。

上述情况都会导致老年代Full GC。

第四：就是“-XX:CMSInitiatingOccupancyFaction”参数，

如果老年代可用内存大于历次新生代GC后进入老年代的对象平均大小，但是老年代已经使用的内存空间超过了这个参数指定的比例，也会自动触发Full GC。默认92%

文章标签：
日志服务
Java
关键词：
代码内存
JVM内存
内存代码
JVM fullgc
内存jvm
相关实践学习
日志服务之使用Nginx模式采集日志
本文介绍如何通过日志服务控制台创建Nginx模式的Logtail配置快速采集Nginx日志并进行多维度分析。
简熵
目录
相关文章
warmhearted
|
2月前
|
缓存 Prometheus 监控
Elasticsearch集群JVM调优设置合适的堆内存大小
Elasticsearch集群JVM调优设置合适的堆内存大小
warmhearted
505 1
三三是该溜子
|
26天前
|
存储 Java 程序员
【JVM】——JVM运行机制、类加载机制、内存划分
JVM运行机制，堆栈，程序计数器，元数据区，JVM加载机制，双亲委派模型
三三是该溜子
54 10
RossyYan
|
12天前
|
安全 测试技术 数据库
代码危机：“内存溢出” 事件的深度剖析与反思
初涉编程时，我坚信严谨逻辑能让代码顺畅运行。然而，“内存溢出”这一恶魔却以残酷的方式给我上了一课。在开发电商平台订单系统时，随着订单量增加，系统逐渐出现处理迟缓甚至卡死的情况，最终排查发现是订单状态更新逻辑中的细微错误导致内存无法及时释放，进而引发内存溢出。这次经历让我深刻认识到微小错误可能带来巨大灾难，从此对待代码更加谨慎，并养成了定期审查和测试的习惯。
RossyYan
30 0
游客vsgxb64qlj7cg
|
1月前
|
存储 监控 算法
深入探索Java虚拟机（JVM）的内存管理机制
本文旨在为读者提供对Java虚拟机（JVM）内存管理机制的深入理解。通过详细解析JVM的内存结构、垃圾回收算法以及性能优化策略，本文不仅揭示了Java程序高效运行背后的原理，还为开发者提供了优化应用程序性能的实用技巧。不同于常规摘要仅概述文章大意，本文摘要将简要介绍JVM内存管理的关键点，为读者提供一个清晰的学习路线图。
游客vsgxb64qlj7cg
97 3
Java开发者
|
1月前
|
存储 算法 Java
Java 内存管理与优化：掌控堆与栈，雕琢高效代码
Java内存管理与优化是提升程序性能的关键。掌握堆与栈的运作机制，学习如何有效管理内存资源，雕琢出更加高效的代码，是每个Java开发者必备的技能。
Java开发者
72 5
土木林森
|
2月前
|
并行计算 算法 测试技术
C语言因高效灵活被广泛应用于软件开发。本文探讨了优化C语言程序性能的策略，涵盖算法优化、代码结构优化、内存管理优化、编译器优化、数据结构优化、并行计算优化及性能测试与分析七个方面
C语言因高效灵活被广泛应用于软件开发。本文探讨了优化C语言程序性能的策略，涵盖算法优化、代码结构优化、内存管理优化、编译器优化、数据结构优化、并行计算优化及性能测试与分析七个方面，旨在通过综合策略提升程序性能，满足实际需求。
土木林森
82 1
爱吃香蕉的猫
|
2月前
|
Java
JVM内存参数
-Xmx[]:堆空间最大内存 -Xms[]:堆空间最小内存，一般设置成跟堆空间最大内存一样的 -Xmn[]:新生代的最大内存 -xx[use 垃圾回收器名称]：指定垃圾回收器 -xss:设置单个线程栈大小 一般设堆空间为最大可用物理地址的百分之80
爱吃香蕉的猫
32 4
Skyund
|
2月前
|
Java
JVM运行时数据区（内存结构）
1）虚拟机栈：每次调用方法都会在虚拟机栈中产生一个栈帧，每个栈帧中都有方法的参数、局部变量、方法出口等信息，方法执行完毕后释放栈帧 （2）本地方法栈：为native修饰的本地方法提供的空间，在HotSpot中与虚拟机合二为一 （3）程序计数器：保存指令执行的地址，方便线程切回后能继续执行代码
Skyund
29 3
warmhearted
|
2月前
|
存储 缓存 监控
Elasticsearch集群JVM调优堆外内存
Elasticsearch集群JVM调优堆外内存
warmhearted
61 1
拉丁解牛说技术
|
2月前
|
Arthas 监控 Java
JVM进阶调优系列(9)大厂面试官:内存溢出几种？能否现场演示一下？| 面试就那点事
本文介绍了JVM内存溢出（OOM）的四种类型：堆内存、栈内存、元数据区和直接内存溢出。每种类型通过示例代码演示了如何触发OOM，并分析了其原因。文章还提供了如何使用JVM命令工具（如jmap、jhat、GCeasy、Arthas等）分析和定位内存溢出问题的方法。最后，强调了合理设置JVM参数和及时回收内存的重要性。
拉丁解牛说技术
141 7

热门文章

最新文章

  • 1
    阿里云服务器经济型、通用算力型、计算型、通用型、内存型实例区别与选择指南
  • 2
    为何内存不够用？微服务改造启动多个Spring Boot的陷阱与解决方案
  • 3
    DMA（Direct Memory Access）：直接内存访问
  • 4
    【运维】如何在Ubuntu中设置一个内存守护进程来确保内存不会溢出
  • 5
    Linux：进程间通信（共享内存详细讲解以及小项目使用和相关指令、消息队列、信号量）
  • 6
    堆内存分配策略解密
  • 7
    从零开始掌握进程间通信：管道、信号、消息队列、共享内存大揭秘
  • 8
    【硬核】C++11并发：内存模型和原子类型
  • 9
    内存卡怎么格式化？6个格式化方法供你选
  • 10
    代码危机：“内存溢出” 事件的深度剖析与反思
  • 1
    linux上如何排查JVM内存过高？
    1111
  • 2
    JVM参数太多？一网打尽常用JVM参数！
    91
  • 3
    深入浅出JVM（十八）之并发垃圾收集器G1
    87
  • 4
    深入浅出JVM（十七）之并发垃圾收集器CMS
    76
  • 5
    深入浅出JVM（十六）之三色标记法与并发可达性分析
    113
  • 6
    深入浅出JVM（十五）之垃圾收集器（上篇）
    79
  • 7
    深入浅出JVM（十四）之内存溢出、泄漏与引用
    64
  • 8
    深入浅出JVM（十三）之垃圾回收算法细节
    76
  • 9
    深入浅出JVM（十二）之垃圾回收算法
    66
  • 10
    深入浅出JVM（十一）之如何判断对象“已死”
    80

    • 相关电子书

    更多
  • 云服务器ECS内存增强型实例re6全新发布
  • JVM的GC
  • 基于JVM的脚本语言开发、运用实践

    • 相关实验场景

    更多
  • 观察进程的并发性
    • 下一篇
    阿里云开通OSS存储服务详细流程