【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. 设置堆空间大小的参数
   * -Xms 用来设置堆空间（年轻代+老年代）的初始内存大小
   *      -X 是jvm的运行参数
   *      ms 是memory start
   * -Xmx 用来设置堆空间（年轻代+老年代）的最大内存大小
   *
   * 2. 默认堆空间的大小
   *      初始内存大小：物理电脑内存大小 / 64
   *      最大内存大小：物理电脑内存大小 / 4
   *
   * 3. 手动设置：-Xms600m -Xmx600m
   *     开发中建议将初始堆内存和最大的堆内存设置成相同的值。
   *
   * 4. 查看设置的参数：方式一： jps   /  jstat -gc 进程id
   *                  方式二：-XX:+PrintGCDetails
   */
  public class HeapSpaceInitial {
      public static void main(String[] args) {
          //返回Java虚拟机中的堆内存总量
          long initialMemory = Runtime.getRuntime().totalMemory() / 1024 / 1024;
          //返回Java虚拟机试图使用的最大堆内存量
          long maxMemory = Runtime.getRuntime().maxMemory() / 1024 / 1024;
  
          System.out.println("-Xms : " + initialMemory + "M");
          System.out.println("-Xmx : " + maxMemory + "M");
  
          System.out.println("系统内存大小为：" + initialMemory * 64.0 / 1024 + "G");
          System.out.println("系统内存大小为：" + maxMemory * 4.0 / 1024 + "G");
  
      }
  }

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

• 设置堆内存大小运行，代码如下：

  public class HeapSpaceInitial {
      public static void main(String[] args) {
          //返回Java虚拟机中的堆内存总量
          long initialMemory = Runtime.getRuntime().totalMemory() / 1024 / 1024;
          //返回Java虚拟机试图使用的最大堆内存量
          long maxMemory = Runtime.getRuntime().maxMemory() / 1024 / 1024;
  
          System.out.println("-Xms : " + initialMemory + "M");
          System.out.println("-Xmx : " + maxMemory + "M");
  
  //        System.out.println("系统内存大小为：" + initialMemory * 64.0 / 1024 + "G");
  //        System.out.println("系统内存大小为：" + maxMemory * 4.0 / 1024 + "G");
  
  
          try {
              Thread.sleep(1000000);
          } catch (InterruptedException e) {
              e.printStackTrace();
          }
      }
  }

　　设置参数为：-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 举例　　

• 代码

  /**
   * -Xms600m -Xmx600m
   */
  public class OOMTest {
      public static void main(String[] args) {
          List<Picture>  list = new ArrayList<>();
          while (true){
              try {
                  Thread.sleep(20);
  
              } catch (InterruptedException e) {
                  e.printStackTrace();
              }
              list.add(new Picture(new Random().nextInt(1024 * 1024)));
          }
       }
  }
  
  
  
  class Picture{
      private byte[] pixels;
  
      public Picture(int length){
          this.pixels = new byte[length];
      }
  } 

• 设置虚拟机参数

　　　　-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 ，就会去养老区养老

　　代码示例

• 代码

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

• 设置参数：-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 晋升的操作，也就是将年轻代中的对象晋升到老年代中

　　

　　代码示例

• 代码

  /**
   * -Xms600m -Xmx600m
   */
  public class HeapInstanceTest {
      byte[] buffe = new byte[new Random().nextInt(1024 * 1024)];
  
      public static void main(String[] args) {
          ArrayList<HeapInstanceTest> list = new ArrayList<>();
          while (true) {
              list.add(new HeapInstanceTest());
              try {
                  Thread.sleep(100);
              } catch (InterruptedException e) {
                  e.printStackTrace();
              }
          }
      }
  }

• 设置参数：-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