zoukankan      html  css  js  c++  java

  • 【JVM】堆内部划分与对象分配（八）

    一、堆的核心概述

    1.1、认识堆内存

    　　堆与进程

    1. 堆针对一个JVM进程来说是唯一的，也就是一个进程只有一个JVM

    2. 但是进程包含多个线程，他们是共享同一堆空间的

    　　对堆的认识

    1. 一个JVM实例只存在一个堆内存，堆也是Java内存管理的核心区域。

    2. Java堆区在JVM启动的时候即被创建，其空间大小也就确定了，堆是JVM管理的最大一块内存空间，并且堆内存的大小是可以调节的。

    3. 《Java虚拟机规范》规定，堆可以处于物理上不连续的内存空间中，但在逻辑上它应该被视为连续的。

    4. 所有的线程共享Java堆，在这里还可以划分线程私有的缓冲区（Thread Local Allocation Buffer，TLAB）。

    5. 《Java虚拟机规范》中对Java堆的描述是：所有的对象实例以及数组都应当在运行时分配在堆上。（The heap is the run-time data area from which memory for all class instances and arrays is allocated）

    6. 老师说：从实际使用角度看的，“几乎”所有的对象实例都在这里分配内存。因为还有一些对象是在栈上分配的（逃逸分析，标量替换）

    7. 数组和对象可能永远不会存储在栈上，因为栈帧中保存引用，这个引用指向对象或者数组在堆中的位置。

    8. 在方法结束后，堆中的对象不会马上被移除，仅仅在垃圾收集的时候才会被移除。

      • 也就是触发了GC的时候，才会进行回收
      • 如果堆中对象马上被回收，那么用户线程就会收到影响，因为有stop the word

    9. 堆，是GC（Garbage Collection，垃圾收集器）执行垃圾回收的重点区域。

    　　栈、堆、方法区关系图如下：

    　　

    1.2、堆内存分区

    　　堆内存细分　　

    1. Java 7及之前堆内存逻辑上分为三部分：新生区+养老区+永久区

      • Young/New Generation Space 新生区，又被划分为Eden区和Survivor区

      • Old/Tenure generation space 养老区

      • Permanent Space永久区 Perm

    2. Java 8及之后堆内存逻辑上分为三部分：新生区+养老区+元空间

      • Young/New Generation Space 新生区，又被划分为Eden区和Survivor区

      • Old/Tenure generation space 养老区

      • Meta Space 元空间 Meta

    　　

    　　注意

    1. 约定：新生区 === 新生代 === 年轻代 、 养老区=== 老年区 === 老年代、 永久区 === 永久代

    2. 堆空间内部结构，JDK1.8之前从永久代 替换成 元空间　

    二、设置堆内存大小与 OOM

    2.1、设置堆内存

    1. Java堆区用于存储Java对象实例，那么堆的大小在JVM启动时就已经设定好了，大家可以通过选项"-Xms"和"-Xmx"来进行设置。

      • -Xms用于表示堆区的起始内存，等价于**-XX:InitialHeapSize**
      • -Xmx用于表示堆区的最大内存，等价于**-XX:MaxHeapSize**

    2. 一旦堆区中的内存大小超过“-Xmx"所指定的最大内存时，将会抛出OutofMemoryError异常。

    3. 通常会将-Xms和-Xmx两个参数配置相同的值，其目的是为了能够在Java垃圾回收机制清理完堆区后不需要重新分隔计算堆区的大小，从而提高性能。

    4. 默认情况下:

      • 初始内存大小：物理电脑内存大小/64
      • 最大内存大小：物理电脑内存大小/4
    • 默认堆大小示例代码 
       1 /**
 2  * 1. 设置堆空间大小的参数
 3  * -Xms 用来设置堆空间（年轻代+老年代）的初始内存大小
 4  *      -X 是jvm的运行参数
 5  *      ms 是memory start
 6  * -Xmx 用来设置堆空间（年轻代+老年代）的最大内存大小
 7  *
 8  * 2. 默认堆空间的大小
 9  *      初始内存大小：物理电脑内存大小 / 64
10  *      最大内存大小：物理电脑内存大小 / 4
11  *
12  * 3. 手动设置：-Xms600m -Xmx600m
13  *     开发中建议将初始堆内存和最大的堆内存设置成相同的值。
14  *
15  * 4. 查看设置的参数：方式一： jps   /  jstat -gc 进程id
16  *                  方式二：-XX:+PrintGCDetails
17  */
18 public class HeapSpaceInitial {
19     public static void main(String[] args) {
20         //返回Java虚拟机中的堆内存总量
21         long initialMemory = Runtime.getRuntime().totalMemory() / 1024 / 1024;
22         //返回Java虚拟机试图使用的最大堆内存量
23         long maxMemory = Runtime.getRuntime().maxMemory() / 1024 / 1024;
24 
25         System.out.println("-Xms : " + initialMemory + "M");
26         System.out.println("-Xmx : " + maxMemory + "M");
27 
28         System.out.println("系统内存大小为：" + initialMemory * 64.0 / 1024 + "G");
29         System.out.println("系统内存大小为：" + maxMemory * 4.0 / 1024 + "G");
30 
31     }
32 }

       不加任何启动参数，运行结果（计算结果与系统实际内存大致相同）：

    • 设置堆内存大小运行，代码如下： 
       1 public class HeapSpaceInitial {
 2     public static void main(String[] args) {
 3         //返回Java虚拟机中的堆内存总量
 4         long initialMemory = Runtime.getRuntime().totalMemory() / 1024 / 1024;
 5         //返回Java虚拟机试图使用的最大堆内存量
 6         long maxMemory = Runtime.getRuntime().maxMemory() / 1024 / 1024;
 7 
 8         System.out.println("-Xms : " + initialMemory + "M");
 9         System.out.println("-Xmx : " + maxMemory + "M");
10 
11 //        System.out.println("系统内存大小为：" + initialMemory * 64.0 / 1024 + "G");
12 //        System.out.println("系统内存大小为：" + maxMemory * 4.0 / 1024 + "G");
13 
14 
15         try {
16             Thread.sleep(1000000);
17         } catch (InterruptedException e) {
18             e.printStackTrace();
19         }
20     }
21 }
      View Code

    　　设置参数为：-Xms600m -Xmx600m 

    　　结果：
    　　

    2.2、查看堆内存

    • 方式一：命令行依次执行如下两个指令
      • jps 查看java进行
      • jstat -gc 进程id

    　　　　在上面Java程序运行时操作，结果如下：
    　　　　

    　　可以看到S0 + S1 + Eden + Old 四个区之和刚好是设置的600m堆内存大小

    • 方式二：设置虚拟机参数 -XX:+PrintGCDetails

    　　　　设置参数为：-Xms600m -Xmx600m -XX:+PrintGCDetails，运行程序，控制台结果如下：
    　　　　

    　　　　其中新生代中S0和S1，谁空谁就时to区，反之是from区

    　　*为什么设置 600MB ，算出来只有 575MB 呢？

      • JVM 认为幸存者 to 区并不存放对象（to 区一直为空），所以没把它算上
      • 可以看到新生区的大小 = 伊甸园区大小 + 幸存者 from 区大小
      • 即 179200KB = 153600KB + 25600KB
    • 方式三：Java VisualVM 查看堆内存

    　　　　1）使用命令：jvisualvm，打开jdk自带的工具Java VisualVM

    　　　　2）安装工具插件Visual GC，步骤：工具->插件->可用插件->选择Visual GC安装
    　　　　　　

    　　　　3）使用Visual GC查看堆内存情况，如下：
    　　　　　　

    2.2、OOM 举例　　

    • 代码 
       1 /**
 2  * -Xms600m -Xmx600m
 3  */
 4 public class OOMTest {
 5     public static void main(String[] args) {
 6         List<Picture>  list = new ArrayList<>();
 7         while (true){
 8             try {
 9                 Thread.sleep(20);
10 
11             } catch (InterruptedException e) {
12                 e.printStackTrace();
13             }
14             list.add(new Picture(new Random().nextInt(1024 * 1024)));
15         }
16      }
17 }
18 
19 
20 
21 class Picture{
22     private byte[] pixels;
23 
24     public Picture(int length){
25         this.pixels = new byte[length];
26     }
27 } 
    • 设置虚拟机参数

    　　　　-Xms600m -Xmx600m

    • 监控堆内存变化：Old 区域一点一点在变大，直到最后一次垃圾回收器无法回收垃圾时，堆内存被撑爆，抛出 OutOfMemoryError 错误

    　　　　可以使用Java VisualVM 观察堆内存变化

    　　　　结果如下：
    　　　　

    • 分析原因：大对象导致堆内存溢出

    　　　　

    三、年轻代与老年代

    3.1、Java 对象分类

    　　存储在JVM中的Java对象可以被划分为两类：

    1. 一类是生命周期较短的瞬时对象，这类对象的创建和消亡都非常迅速（据统计Java80%的对象都是很快消亡的）

      • 生命周期短的，及时回收即可

      • 另外一类对象的生命周期却非常长，在某些极端的情况下还能够与JVM的生命周期保持一致

    2. Java堆区进一步细分的话，可以划分为年轻代（YoungGen）和老年代（oldGen）

    3. 其中年轻代又可以划分为Eden空间、Survivor0空间和Survivor1空间（有时也叫做from区、to区）

    3.2、配置新老比例

    　　配置新生代与老年代在堆结构的占比（一般不会调）

    1. 默认**-XX:NewRatio**=2，表示新生代占1，老年代占2，新生代占整个堆的1/3

    2. 可以修改**-XX:NewRatio**=4，表示新生代占1，老年代占4，新生代占整个堆的1/5

    3. 当发现在整个项目中，生命周期长的对象偏多，那么就可以通过调整老年代的大小，来进行调优

    　　

    　　新生区中的比例

    1. 在HotSpot中，Eden空间和另外两个survivor空间缺省所占的比例是8 : 1 : 1，当然开发人员可以通过选项**-XX:SurvivorRatio**调整这个空间比例。比如-XX:SurvivorRatio=8

    2. 几乎所有的Java对象都是在Eden区被new出来的。绝大部分的Java对象的销毁都在新生代进行了（有些大的对象在Eden区无法存储时候，将直接进入老年代）

    3. IBM公司的专门研究表明，新生代中80%的对象都是“朝生夕死”的。

    4. 可以使用选项"-Xmn"设置新生代最大内存大小，但这个参数一般使用默认值就可以了。

    5. 新生区的对象默认生命周期超过 15 ，就会去养老区养老

    　　代码示例

    • 代码 
       1 /**
 2  * -Xms600m -Xmx600m
 3  *
 4  * -XX:NewRatio ： 设置新生代与老年代的比例。默认值是2.
 5  * -XX:SurvivorRatio ：设置新生代中Eden区与Survivor区的比例。默认值是8
 6  * -XX:-UseAdaptiveSizePolicy ：关闭自适应的内存分配策略  （暂时用不到）
 7  * -Xmn:设置新生代的空间的大小。 （一般不设置）
 8  *
 9  */
10 public class EdenSurvivorTest {
11     public static void main(String[] args) {
12         System.out.println("我是来打酱油的～～～");
13 
14         try {
15             Thread.sleep(1000000);
16         } catch (InterruptedException e) {
17             e.printStackTrace();
18         }
19     }
20 }

    • 设置参数：-Xms600m -Xmx600m，运行程序

    • 通过命令行查看各种比例

      • 查看新生代与老年代的比例

        • 命令：jps

        • 命令：jinfo -flag NewRatio 进程id

      • 查看新生区中伊甸园区与幸存者区的比例

        • 命令：jps

        • 命令：jinfo -flag SurvivorRatio 进程id

    　　　　查看结果：
    　　　　

    　　注：

    　　　　情况1：参数：-Xms600m -Xmx600m，未设置新生区中伊甸园区与幸存者区的比例时，默认SurvivorRatio为8，但是实际通过查看堆内中存伊甸园区与幸存者内存，发现实际比例时6

    　　　　情况2：参数：-Xms600m -Xmx600m -XX:SurvivorRatio=8，设置了伊甸园区与幸存者区的比例时，查看SurvivorRatio参数值为8，通过查看堆内中存伊甸园区与幸存者内存，发现实际比例为8

    4、图解对象分配过程

    4.1、对象分配过程

    　　对象分配难点：

    　　为新对象分配内存是一件非常严谨和复杂的任务，JVM的设计者们不仅需要考虑内存如何分配、在哪里分配等问题，并且由于内存分配算法与内存回收算法密切相关，所以还需要考虑GC执行完内存回收后是否会在内存空间中产生内存碎片。

    　　对象分配过程

    1. new的对象先放伊甸园区。此区有大小限制。

    2. 当伊甸园的空间填满时，程序又需要创建对象，JVM的垃圾回收器将对伊甸园区进行垃圾回收（MinorGC），将伊甸园区中的不再被其他对象所引用的对象进行销毁。再加载新的对象放到伊甸园区。

    3. 然后将伊甸园中的剩余对象移动到幸存者0区。

    4. 如果再次触发垃圾回收，此时上次幸存下来的放到幸存者0区的，如果没有回收，就会放到幸存者1区。

    5. 如果再次经历垃圾回收，此时会重新放回幸存者0区，接着再去幸存者1区。

    6. 啥时候能去养老区呢？可以设置次数。默认是15次。可以设置新生区进入养老区的年龄限制，设置 JVM 参数：-XX:MaxTenuringThreshold=N 进行设置

    7. 在养老区，相对悠闲。当养老区内存不足时，再次触发GC：Major GC，进行养老区的内存清理

    8. 若养老区执行了Major GC之后，发现依然无法进行对象的保存，就会产生OOM异常。

    4.2、图解对象分配

    • 我们创建的对象，一般都是存放在Eden区的，当我们Eden区满了后，就会触发GC操作，一般被称为 YGC / Minor GC操作

    　　　

    • 当我们进行一次垃圾收集后，红色的对象将会被回收，而绿色的独享还被占用着，存放在S0(Survivor From)区。同时我们给每个对象设置了一个年龄计数器，经过一次回收后还存在的对象，将其年龄加 1。

    • 同时Eden区继续存放对象，当Eden区再次存满的时候，又会触发一个MinorGC操作，此时GC将会把 Eden和Survivor From中的对象进行一次垃圾收集，把存活的对象放到 Survivor To区，同时让存活的对象年龄 + 1

    　　

    • 我们继续不断的进行对象生成和垃圾回收，当Survivor中的对象的年龄达到15的时候，将会触发一次 Promotion 晋升的操作，也就是将年轻代中的对象晋升到老年代中

    　　

    　　代码示例

    • 代码 
       1 /**
 2  * -Xms600m -Xmx600m
 3  */
 4 public class HeapInstanceTest {
 5     byte[] buffe = new byte[new Random().nextInt(1024 * 1024)];
 6 
 7     public static void main(String[] args) {
 8         ArrayList<HeapInstanceTest> list = new ArrayList<>();
 9         while (true) {
10             list.add(new HeapInstanceTest());
11             try {
12                 Thread.sleep(100);
13             } catch (InterruptedException e) {
14                 e.printStackTrace();
15             }
16         }
17     }
18 }

    • 设置参数：-Xms600m -Xmx600m，运行程序

    • 通过Java VisualVM的Visual GC插件观察内存变化

    　　

    4.3、特殊情况说明

    　　思考：幸存区满了咋办？

    1. 特别注意，在Eden区满了的时候，才会触发MinorGC，而幸存者区满了后，不会触发MinorGC操作

    2. 如果Survivor区满了后，将会触发一些特殊的规则，也就是可能直接晋升老年代

    　　对象分配的特殊情况　　

    1. 如果来了一个新对象，先看看 Eden 是否放的下？

      • 如果 Eden 放得下，则直接放到 Eden 区

      • 如果 Eden 放不下，则触发 YGC ，执行垃圾回收，看看还能不能放下？放得下最好当然最好咯~~~

    2. 将对象放到老年区又有两种情况：

      • 如果 Eden 执行了 YGC 还是无法放不下该对象，那没得办法，只能说明是超大对象，只能直接怼到老年代

      • 那万一老年代都放不下，则先触发重 GC ，再看看能不能放下，放得下最好，但如果还是放不下，那只能报 OOM 啦~~~

    3. 如果 Eden 区满了，将对象往幸存区拷贝时，发现幸存区放不下啦，那只能便宜了某些新对象，让他们直接晋升至老年区

    　　

    　　总结

    1. 针对幸存者s0，s1区的总结：复制之后有交换，谁空谁是to

    2. 关于垃圾回收：频繁在新生区收集，很少在老年代收集，几乎不在永久代和元空间进行收集

    3. 新生代采用复制算法的目的：是为了减少内碎片

    4.4、常用调优工具

    　　常用调优工具

    1. JDK命令行

    2. Eclipse：Memory Analyzer Tool

    3. Jconsole

    4. Visual VM（实时监控 推荐~）

    5. Jprofiler（推荐~）

    6. Java Flight Recorder（实时监控）

    7. GCViewer

    8. GCEasy
  • 相关阅读:
    Java项目远程调试
    Linux虚拟机安装
    研究Quarkus出现的各种错误集锦
    debian 安装 ifconfig ping
    adb shell pm list packages 高级用法
    2020年深港澳金融科技师专才计划一级考试报名简章
    k8s组件
    查询Kubernetes中etcd数据
    curl
    kubelet
  • 原文地址：https://www.cnblogs.com/h--d/p/14169149.html
Copyright © 2011-2022 走看看