JVM全面分析之堆

目录

• 堆的核心概述
  • 堆空间结构：
• 设置堆内存大小与OOM
• 年轻代与老年代
• 图解对象分配过程
• Minor GC、Major GC、Full GC
  • 年轻代GC（Minor GC）触发机制：
  • 老年代GC（Major GC / Full GC）触发机制：
  • Full GC触发机制
• 内存分配策略
• 为对象分配内存：TLAB
• 小结对空间的参数设置堆
• 堆是分配对象的唯一选择吗？
  • 参数设置
  • 代码优化

堆的核心概述

• 一个JVM实例只存在一个堆内存，堆也是Java内存管理的核心区域。
• Java堆区在JVM启动的时候即被创建，其空间大小也就确定了，是JVM管理的最大一块内存空间。
    * 堆内存的大小是可以调节的
• 《Java虚拟机规范》规定，堆可以处于物理上不连续的内存空间，但在逻辑上它应该被视为连续的。
• 所有的线程共享Java堆，在这里还可以划分线程私有的缓冲区（Thread Local Allocation Buffer, TLAB）
• 《java虚拟机规范》中对JAVA堆的描述是：所有的对象实例以及数组都应当在运行时分配在堆上。
    * 我要说的是：”几乎“所有的对象实例都在这里分配内存。
• 数组和对象可能永远不会存储在栈上，因为栈帧中保存引用，这个引用指向对象或者数组在堆中的位置。
• 在方法结束后，堆中的对象不会马上被移除，仅仅在垃圾收集的时候才会被移除。
• 堆，是GC执行垃圾回收的重点区域。

public class SimpleTest {
    private int id;

    public SimpleTest(int id) {
        this.id = id;
    }

    public void show() {
        System.out.println("hello world");
    }

    public static void main(String[] args) {
        SimpleTest s1 = new SimpleTest(1);
        SimpleTest s2 = new SimpleTest(2);

        int[] arr = new int[10];
        Object[] arr1 = new Object[10];
    }
}

其内存结构如下：

栈存放引用变量的地址值，堆空间中实打实的存放对象实体；那这个对象所属类的信息在哪呢，在方法区中。

堆空间结构：

逻辑上对堆分为新生代、老年代、永久代/元空间。实际上堆只针对新生代和老年代

使用+XX:+PrintGCDetails可以显示gc的细节

设置堆内存大小与OOM

• Java堆区用于存储Java对象实例，那么堆的大小在JVM启动时就已经设定好了，大家可以通过选项”-Xms“和”-Xmx“进行设置
    * "-Xms"用于表示堆区的起始内存，等价于-XX:InitialHeapSize
    * "-Xmx"用于表示堆区的最大内存，等价于-XX:MaxHeapSize
    * -X 是jvm运行参数，ms 是memory start
• 一旦堆区中的内存大小超过”-Xmx“所指定的最大内存时，将会抛出OutOfMemoryError异常。
• 通常会将 -Xmx 和 -Xms 两个参数配置相同的值，其目的是为了能够在java垃圾回收机制清理完堆区后不需要重新分割计算堆区的大小，从而提高性能。
• 默认情况下，初始内存大小：物理电脑内存大小 / 64
        最大内存大小：物理电脑内存大小 / 4

public class JvmMemory {
    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");
    }
}

如果不添加如下参数：-Xms600m -Xmx600m，则显示的是系统参数。
如果添加如下参数：-Xms600m -Xmx600m，则结果如下：

-Xms : 575M
-Xmx : 575M

此处有一个疑问，我们设置的是600，为何显示的是575呢，我们一起去探究一下原因：
增加Thread.sleep(10000000)代码，让程序”睡着“，然后在终端使用jps查询程序的进程号如：31225，然后在终端执行命令：jstat -gc 31225。结果如下：

S0C    S1C    S0U    S1U      EC       EU        OC         OU       MC     MU    CCSC   CCSU   YGC     YGCT    FGC    FGCT     GCT
25600.0 25600.0  0.0    0.0   153600.0 18720.0   409600.0     0.0     4480.0 780.9  384.0   76.6       0    0.000   0      0.000    0.000

  S0C表示幸存者0区容量，S0U表示幸存者0去使用容量，依次类推，我们计算下堆空间总大小：(S0C+S1C+EC+OC) / 1024= (25600+25600+153600 + 409600) / 1024 = 600。此处看到确实是600。那为何程序输出575M呢。别急，接着往下看：(S0C+EC+OC) / 1024= (25600+153600 + 409600) / 1024 = 575。原因为：幸存者区同一个时刻只能有一个在使用。

另一种查看方式：运行程序前添加如下参数：-XX:+PrintGCDetails

年轻代与老年代

堆内存的细分图：

堆内存比例图

配置新生代与老年代在堆结构的占比：

• 默认-XX:NewRatio=2，表示新生代占1，老年代占2，新生代占整个堆的1/3
• 可以修改-XX:NewRatio=4，表示新生代占1，老年代占4，新生代占整个堆的1/5
  一般情况下不会修改这个比例

在HotSpot中，Eden空间和另外两个Survivor空间缺省所占的比例为8：1：1，当然开发人员可以通过选项 ”-XX:SurvivorRatio“ 调整这个空间的比例。比如：-XX:SurvivorRatio=8。几乎所有的Java对象都是Eden区被new出来的。绝大部分的Java对象的销毁都在新生代进行了。
可以使用选项”-Xmn“设置新生代最大内存大小。（一般使用默认值就可以了）

默认-XX:SurvivorRatio的值为8，但是实际上Eden：Survivor0：Survivor1 = 6:1:1，这是为什么呢，这里有这样一个参数，-XX:UseAdaptiveSizePolicy（关闭自适应的内存分配策略），但是，添加此参数发现还是不起作用。此处应该使用-XX:SurvivorRatio=8显示配置。

此处再总结一下涉及到的参数：

• -XX:NewRatio 新生代与老年代的比例。默认值为2
• -XX:SurvivorRatio 设置新生代中Eden和Survivor区的比例。默认值为8，实际是6
• -XX:-UseAdaptiveSizePolicy 关闭自适应的内存分配策略（暂时用不到）
• -Xmn 设置新生代的空间的大小

图解对象分配过程

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

1. new的对象先放伊甸园去。此区有大小限制。
2. 当伊甸园的空间填满时，程序有需要创建对象，JVM的垃圾回收器将对伊甸园区进行垃圾回收（Minor GC），将伊甸园区中的不再被其他对象所引用的对象进行销毁。再加载新的对象到伊甸园区。
3. 然后伊甸园中的剩余对象移动到幸存者0区
4. 如果再次触发垃圾回收，此时上次幸存下来的放到幸存者0区的，如果没有回收，就会放到幸存者1区。
5. 如果再次经历垃圾回收，此时会重新放回幸存者0区，接着再去幸存者1区
6. 啥时候能去养老区呢？可以设置次数，默认是15次。可以设置参数：-XX:MaxTenuringThreshold=N进行设置。
7. 在养老区，相对悠闲。当养老区内存不足时，再次触发GC：Major GC，进行养老区的内存清理
8. 若养老区执行了Major GC之后发现依然无法进行对象的保存，就会产生OOM异常：

   java.lang.OutOfMemoryError: Java heap space

  需要注意的是：

• 只有当伊甸园区满的时候才会触发Young/Minor GC。幸存者区满的时候不会触发Young/Minor GC。但是Young/Minor GC会同时清理伊甸园去和幸存者区。
• 如果幸存者区满了，则直接放入养老区。
• 如果分配的任务需要占用很大空间，而伊甸园区空间不足，则需要放入养老区。

总结

• 关于垃圾回收：频繁在新生区收集，很少在养老区收集，几乎不再永久区/元空间收集。

特殊情况:

Minor GC、Major GC、Full GC

JVM在进行GC时，并非每次都对三个内存（新生代，老年代、永久代）区域一起回收的，大部分时候回收的都是指新生代。

针对HotSpot VM的实现，它里面的GC按照回收区域又分为两大种类型：一种是部分收集（Partial GC），一种是整堆收集（Full GC）

• 部分收集：不是完整收集整个Java堆的垃圾收集。其中又分为：
    * 新生代收集（Minor GC / Young GC）:只是新生代（Eden、S0、S1）的垃圾收集
    * 老年代收集（Major GC / Old GC）：只是老年代的垃圾收集。
      * 目前只有CMS GC会有单独收集老年代的行为。
      * 注意：很多时候Major GC会和Full GC混淆使用，需要具体分辨是老年代回收还是整堆回收。
    * 混合收集（Mixed GC）：收集整个新生代以及部分老年代的垃圾收集。
      * 目前只有G1 GC会有这种行为
• 整堆收集（Full GC）：收集整个java堆和方法区的垃圾收集。

年轻代GC（Minor GC）触发机制：

• 当年轻代空间不足时，就会触发Minor GC，这里的年轻代满指的是Eden代满，Survivor满不会引发GC。（每次Minor GC会清理年轻代的内存）
• 因为Java对象大多都具备朝生夕灭的特性，所以Minor GC非常频繁，一般回收速度也比较快。
• Minor GC会引发STW，暂停其他用户的线程，等垃圾回收结束，用户线程才回复运行。

老年代GC（Major GC / Full GC）触发机制：

• 指发生在老年代的GC，对象从老年代消失时，我们说”Major GC“或”Full GC“发生了。
• 出现了Major GC，经常会伴随至少一次的Minor GC（但非绝对的，在Parallel Scavenge收集器的收集策略里就有直接进行Major GC的策略选择过程）。
    * 也就是在老年代空间不足时，会先尝试触发Minor GC。如果之后空间还不足，则触发Major GC.
• Major GC的速度一般会比Minor GC慢10倍以上，STW的时间更长
• 如果Major GC后，内存还不足，就报OOM了。

Full GC触发机制

触发Full GC执行的情况有以下五种：

1. 调用System.gc()时，系统建议执行Full GC，但是不必然执行
2. 老年代空间不足
3. 方法区空间不足
4. 通过Minor GC后进入老年代的平均大小大于老年代的可用内存
5. 由Eden区、survivor space0区（From space）向survivor space1区(To space)复制时，对象大小大于To Space可用内存，则把该对象转存到老年代，且老年代的可用内存小于该对象大小

说明：full gc 是开发或调优中尽量要避免的，这样暂停时间会短一些

内存分配策略

如果对象在Eden出生并经过第一次Minor GC后仍然存活，并且能被Survivor 容纳的话，将被移动到Survivor空间中，并将对象年龄设为1。对象在Survivor区中每熬过一次Minor GC，年龄就增加1岁，当它年龄增加到一定程度（默认15岁，其实每个JVM、每个GC都有所不同）时，就会被晋升到老年代中。

对象晋升老年代的年龄阈值，可以通过选项 -XX:MaxTenuringThreshold来设置。

针对不同年龄的对象分配原则如下所示：

• 优先分配到Eden
• 大对象直接分配到老年代
    * 尽量避免程序中出现过多的大对象
• 长期存活的对象分配到老年代
• 动态对象年龄判断
    * 如果Survivor区中相同年龄的所有对象大小的总和大于Survivor空间的一半，年龄大于或等于该年龄的对象可以直接进入老年代，无序等到MaxTenuringThreshold中要求的年龄。
• 空间分配担保
    * -XX:HandlePromotionFailure

下面用代码展示大对象的分配

public class YoungAndOldTest {
    public static void main(String[] args) {
        Byte[] bytes = new Byte[1024 * 1024 * 20];
    }
}

增加如下参数设置
-Xms60m -Xmx60m -XX:SurvivorRatio=8 -XX:NewRatio=2 -XX:+PrintGCDetails

Heap
 PSYoungGen      total 18432K, used 6295K [0x00000007bec00000, 0x00000007c0000000, 0x00000007c0000000)
  eden space 16384K, 38% used [0x00000007bec00000,0x00000007bf225d58,0x00000007bfc00000)
  from space 2048K, 0% used [0x00000007bfe00000,0x00000007bfe00000,0x00000007c0000000)
  to   space 2048K, 0% used [0x00000007bfc00000,0x00000007bfc00000,0x00000007bfe00000)
 ParOldGen       total 40960K, used 20480K [0x00000007bc400000, 0x00000007bec00000, 0x00000007bec00000)
  object space 40960K, 50% used [0x00000007bc400000,0x00000007bd800010,0x00000007bec00000)
 Metaspace       used 3138K, capacity 4496K, committed 4864K, reserved 1056768K
  class space    used 341K, capacity 388K, committed 512K, reserved 1048576K

为对象分配内存：TLAB

• 从内存模型而不是垃圾收集的角度，对Eden区域继续进行划分，JVM为每个线程分配了一个私有缓存区域，它包含在Eden空间内。

• 多线程同时分配内存时，使用TLAB可以避免一系列的非线程安全问题，同时还能够提升内存分配的吞吐量，因此我们可以将这种内存分配方式称之为快速分配策略。

• 据我所知所有OpenJDK衍生出来的JVM都提供了TLAB的设计。
  

• 尽管不是所有的对象实例都能够在TLAB中成功分配内存，但JVM确实是将TLAB作为内存分配的首选。

• 在程序中，开发人员可以通过选项 ”-XX:UseTLAB“设置是否开启TLAB空间。

• 默认情况下，TLAB空间的内存非常小，仅占有整个Eden空间的1%，当然我们可以通过选项"-XX:TLABWasteTargetPercent" 设置TLAB空间所占用Eden空间的百分比大小。

• 一旦对象在TLAB空间分配内存失败时，JVM就会尝试着通过使用加锁机制确保数据操作的原子性，从而直接在Eden空间中分配内存。
  

小结对空间的参数设置堆

在发生Minor GC之前，虚拟机会检查老年代最大可用的连续空间是否大于新生代所有对象的总空间。
  * 如果大于，则此次Minor GC是安全的。
  * 如果小于，则虚拟机会查看-XX:HandlePromotionFailure设置值是否允许担保失败。
    如果HandlePromotionFailure=true，那么会继续检查老年代最大可用连续空间是否大于历次晋升到老年代的对象的平均年龄。
        如果大于，则尝试进行一次Minor GC，但这次Minor GC依然是有风险的。
        如果小于，则改为进行一次Full GC.
    如果HandlePromotionFailure=false，则改为进行一次Full GC.
在JDK Update24之后，（或者直接说JDK7之后）HandlePromotionFailure参数不会再影响到虚拟机的空间分配担保策略，观察OpenJDK中的源码变化，虽然源码中还定义了此参数，但是在代码中已经不会再使用它。JDK6 Update24之后的规则变为只要老年代的连续空间大于新生代对象总大小或者历次晋升的平均大小就会进行Minor GC，否则将进行Full GC.

堆是分配对象的唯一选择吗？

在Java虚拟机中，对象是在Java堆中分配内存的，这是一个普遍的常识。但是，有一种特殊的情况，那就是如果经过逃逸分析（Escape Analysis）后发现，一个对象并没有逃逸出方法的话，那么就可能被优化成栈上分配。这样就无需在堆上分配内存，也无须进行垃圾回收了。这也是最常见的堆外存储技术。

*  逃逸分析的基本行为就是分析对象动态作用域：

• 当一个对象在方法中被定义后，对象只在方法内部使用，则认为没有发生逃逸。
• 当一个对象在方法中被定义后，它被外部方法所引用，则认为发生逃逸，例如作为调用参数传递到其他地方中。

参数设置

• 在JDK 6U23版本之后，HotSpot中默认就已经开启了逃逸分析。
• 如果使用的是较早的版本，开发人员则可以通过：
    * 选项"-XX:DoEscapeAnalysis"显示开启逃逸分析
    * 通过选项”-XX:+PrintEscapeAnalysis“查看逃逸分析的筛选结果

代码优化

  同步省略
  在动态编译同步块的时候，JIT编译器可以借助逃逸分析来判断同步块所使用的锁对象是否只能够被一个线程访问而没有被发布到其他线程。如果没有，那么JIT编译器在编译这个同步块的时候就会取消这部分代码的同步。这样就能大大提高并发和性能。这个取消同步的过程就叫同步省略，也叫锁消除。

  分离对象或标量替换

  有的对象可能不需要作为一个连续的内存结构存在也可以被访问到，那么对象的部分（或全部）可以不存储在内存，而是存储在CPU寄存器中。

  标量（Scalar）是指一个无法再分解成更小的数据的数据。Java中的原始数据类型就是标量。

  相对的，那些可以分解的数据叫做聚合量。Java中的对象就是聚合量，因为他可以分解成其他聚合量和标量。
在JIT阶段，如果经过逃逸分析，发现一个对象不会被外界访问的话，那么经过JIT优化，就会把这个对象拆解成若干个其中包含的若干个成员变量来替换。这个过程就是标量替换

标量替换设定参数：-XX:-EliminateAllocations