04-堆

2022-07-18

04-堆

JVM之运行时数据区(三)-- 堆

一. 堆的核心概述

1.1 堆与进程

  1. 堆针对一个JVM进程来说是唯一的。也就是一个进程只有一个JVM实例,一个JVM实例中就有一个运行时数据区,一个运行时数据区只有一个堆和一个方法区。
  2. 但是进程包含多个线程,他们是共享同一堆空间的

1.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. 在方法结束后,堆中的对象不会马上被移除,仅仅在垃圾收集的时候才会被移除。
    • 也就是触发了GC的时候,才会进行回收
    • 如果堆中对象马上被回收,那么用户线程就会收到影响,因为有stop the word
  8. 堆,是GC(Garbage Collection,垃圾收集器)执行垃圾回收的重点区域。

1.3 堆内存细分

现代垃圾收集器大部分都基于分代收集理论设计,堆空间细分为:

  1. Java7 及之前堆内存逻辑上分为三部分:新生区+养老区+永久区
    • Young Generation Space 新生区 Young/New
      • 又被划分为Eden区和Survivor区
    • Old generation space 养老区 Old/Tenure
    • Permanent Space 永久区 Perm
  2. Java 8及之后堆内存逻辑上分为三部分:新生区+养老区+元空间
    • Young Generation Space 新生区,又被划分为Eden区和Survivor区
    • Old generation space 养老区
    • Meta Space 元空间 Meta

image-20210719222404207

1.4 设置堆内存大小

  1. Java堆区用于存储Java对象实例,那么堆的大小在JVM启动时就已经设定好了,可以通过选项"-Xms"和"-Xmx"来进行设置。
    • -Xms用于表示堆区的起始内存,等价于**-XX:InitialHeapSize**
    • -Xmx则用于表示堆区的最大内存,等价于**-XX:MaxHeapSize**
  2. 一旦堆区中的内存大小超过“-Xmx"所指定的最大内存时,将会抛出OutofMemoryError异常。
  3. 通常会将-Xms和-Xmx两个参数配置相同的值
  • 原因:假设两个不一样,初始内存小,最大内存大。在运行期间如果堆内存不够用了,会一直扩容直到最大内存。如果内存够用且多了,也会不断的缩容释放。频繁的扩容和释放造成不必要的压力,避免在GC之后调整堆内存给服务器带来压力。
  • 如果两个设置一样的就少了频繁扩容和缩容的步骤。内存不够了就直接报OOM

默认情况下:

  • 初始内存大小:物理电脑内存大小/64
  • 最大内存大小:物理电脑内存大小/4
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,输出结果为:

-Xms : 575M
-Xmx : 575M

少的25M去哪里了呢?

查看方法一

jps / jstat -gc 进程id

image-20210719230233949

SOC: S0区总共容量
S1C: S1区总共容量
S0U: S0区使用的量
S1U: S1区使用的量
EC: 伊甸园区总共容量
EU: 伊甸园区使用的量
OC: 老年代总共容量
OU: 老年代使用的量

通过计算可以知道:

S0 + S1 + EC + OC = 25600 + 25600 + 153600 + 409600 = 614400KB

614400 / 1024 = 600M

因此总的堆空间大小为600M是没有问题的,少的25M是S0或者S1区的大小(25600 / 1024 = 25M),因为在使用时只会用到一个幸存者区

查看方式

-XX:+PrintGCDetails

Heap
 PSYoungGen      total 179200K, used 12288K [0x00000000f3800000, 0x0000000100000000, 0x0000000100000000)
  eden space 153600K, 8% used [0x00000000f3800000,0x00000000f4400210,0x00000000fce00000)
  from space 25600K, 0% used [0x00000000fe700000,0x00000000fe700000,0x0000000100000000)
  to   space 25600K, 0% used [0x00000000fce00000,0x00000000fce00000,0x00000000fe700000)
 ParOldGen       total 409600K, used 0K [0x00000000da800000, 0x00000000f3800000, 0x00000000f3800000)
  object space 409600K, 0% used [0x00000000da800000,0x00000000da800000,0x00000000f3800000)
 Metaspace       used 3301K, capacity 4496K, committed 4864K, reserved 1056768K
  class space    used 354K, capacity 388K, committed 512K, reserved 1048576K

1.5 OOM

java.lang.OutOfMemoryError: Java heap space

public class OOMTest {

    public static void main(String[] args) {
        ArrayList<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];
    }
}

二. 堆内存详解

2.1 年轻代与老年代

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

  • 一类是生命周期较短的瞬时对象,这类对象的创建和消亡都非常迅速
  • 另外一类对象的生命周期却非常长,在某些极端的情况下还能够与JVM的生命周期保持一致

2、Java堆区进一步细分的话,可以划分为年轻代(YoungGen)和老年代(oldGen)

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

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

  • 默认-XX:NewRatio=2,表示新生代占1,老年代占2,新生代占整个堆的1/3
  • 可以修改-XX:NewRatio=4,表示新生代占1,老年代占4,新生代占整个堆的1/5
  1. 在HotSpot中,Eden空间和另外两个survivor空间缺省所占的比例是8 : 1 : 1,
  2. 当然开发人员可以通过选项**-XX:SurvivorRatio**调整这个空间比例。比如-XX:SurvivorRatio=8
  3. 几乎所有的Java对象都是在Eden区被new出来的。
  4. 绝大部分的Java对象的销毁都在新生代进行了(有些大的对象在Eden区无法存储时候,将直接进入老年代),IBM公司的专门研究表明,新生代中80%的对象都是“朝生夕死”的。
  5. 可以使用选项"-Xmn"设置新生代最大内存大小,但这个参数一般使用默认值就可以了。

2.2 对象分配过程

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

image-20210720001207435

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

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

    下一次再进行GC的时候,

    1、这一次的s0区为空,所以成为下一次GC的S1区

    2、这一次的s1区则成为下一次GC的S0区

    3、也就是说s0区和s1区在互相转换。

image-20210720001259098

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

    image-20210720001349191

  2. 当老年区也满后,会触发一次Major GC,同时回收老年代和年轻代

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

2.3 特殊情况说明

对象分配的特殊情况

  1. 如果来了一个新对象,先看看 Eden 是否放的下?
    • 如果 Eden 放得下,则直接放到 Eden 区
    • 如果 Eden 放不下,则触发 YGC ,执行垃圾回收,看看还能不能放下?
  2. 将对象放到老年区又有两种情况:
    • 如果 Eden 执行了 YGC 还是无法放不下该对象,那没得办法,只能说明是超大对象,只能直接放到老年代
    • 那万一老年代都放不下,则先触发FullGC ,再看看能不能放下,放得下最好,但如果还是放不下,那只能报 OOM
  3. 如果 Eden 区满了,将对象往幸存区拷贝时,发现幸存区放不下啦,那只能便宜了某些新对象,让他们直接晋升至老年区

2.4 堆空间分代思想

为什么要把Java堆分代?不分代就不能正常工作了吗?经研究,不同对象的生命周期不同。70%-99%的对象是临时对象。

  • 新生代:有Eden、两块大小相同的survivor(又称为from/to或s0/s1)构成,to总为空。
  • 老年代:存放新生代中经历多次GC仍然存活的对象。

其实不分代完全可以,分代的唯一理由就是优化GC性能。

  • 如果没有分代,那所有的对象都在一块,就如同把一个学校的人都关在一个教室。GC的时候要找到哪些对象没用,这样就会对堆的所有区域进行扫描。(性能低)
  • 而很多对象都是朝生夕死的,如果分代的话,把新创建的对象放到某一地方,当GC的时候先把这块存储“朝生夕死”对象的区域进行回收,这样就会腾出很大的空间出来。(多回收新生代,少回收老年代,性能会提高很多)

2.5 对象内存分配策略

  1. 如果对象在Eden出生并经过第一次Minor GC后仍然存活,并且能被Survivor容纳的话,将被移动到Survivor空间中,并将对象年龄设为1。
  2. 对象在Survivor区中每熬过一次MinorGC,年龄就增加1岁,当它的年龄增加到一定程度(默认为15岁,其实每个JVM、每个GC都有所不同)时,就会被晋升到老年代
  3. 对象晋升老年代的年龄阀值,可以通过选项**-XX:MaxTenuringThreshold**来设置

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

  1. 优先分配到Eden:开发中比较长的字符串或者数组,会直接存在老年代,但是因为新创建的对象都是朝生夕死的,所以这个大对象可能也很快被回收,但是因为老年代触发Major GC的次数比 Minor GC要更少,因此可能回收起来就会比较慢
  2. 大对象直接分配到老年代:尽量避免程序中出现过多的大对象
  3. 长期存活的对象分配到老年代
  4. 动态对象年龄判断:如果Survivor区中相同年龄的所有对象大小的总和大于Survivor空间的一半,年龄大于或等于该年龄的对象可以直接进入老年代,无须等到MaxTenuringThreshold中要求的年龄。
  5. 空间分配担保: -XX:HandlePromotionFailure 。

2.6 TLAB

TLAB(Thread Local Allocation Buffer)

  1. 从内存模型而不是垃圾收集的角度,对Eden区域继续进行划分,JVM为每个线程分配了一个私有缓存区域,它包含在Eden空间内
  2. 多线程同时分配内存时,使用TLAB可以避免一系列的非线程安全问题,同时还能够提升内存分配的吞吐量,因此我们可以将这种内存分配方式称之为快速分配策略
  3. 据我所知所有OpenJDK衍生出来的JVM都提供了TLAB的设计。

TLAB的作用

  1. 堆区是线程共享区域,任何线程都可以访问到堆区中的共享数据
  2. 由于对象实例的创建在JVM中非常频繁,因此在并发环境下从堆区中划分内存空间是线程不安全的
  3. 为避免多个线程操作同一地址,需要使用加锁等机制,进而影响分配速度。

TLAB补充说明

  1. 尽管不是所有的对象实例都能够在TLAB中成功分配内存,但JVM确实是将TLAB作为内存分配的首选
  2. 在程序中,开发人员可以通过选项“-XX:UseTLAB”设置是否开启TLAB空间。
  3. 默认情况下,TLAB空间的内存非常小,仅占有整个Eden空间的1%,当然我们可以通过选项“-XX:TLABWasteTargetPercent”设置TLAB空间所占用Eden空间的百分比大小。
  4. 一旦对象在TLAB空间分配内存失败时,JVM就会尝试着通过使用加锁机制确保数据操作的原子性,从而直接在Eden空间中分配内存。

三. GC概述

3.1 GC分类

  1. 我们都知道,JVM的调优的一个环节,也就是垃圾收集,我们需要尽量的避免垃圾回收,因为在垃圾回收的过程中,容易出现STW(Stop the World)的问题,而 Major GC 和 Full GC出现STW的时间,是Minor GC的10倍以上
  2. JVM在进行GC时,并非每次都对上面三个内存区域一起回收的,大部分时候回收的都是指新生代。针对Hotspot VM的实现,它里面的GC按照回收区域又分为两大种类型:一种是部分收集(Partial GC),一种是整堆收集(FullGC)
  • 部分收集:不是完整收集整个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堆和方法区的垃圾收集。

由于历史原因,外界各种解读,majorGC和Full GC有些混淆。

3.2 Young GC

年轻代 GC(Minor GC)触发机制

  1. 当年轻代空间不足时,就会触发Minor GC,这里的年轻代满指的是Eden代满。Survivor满不会主动引发GC,在Eden区满的时候,会顺带触发s0区的GC,也就是被动触发GC(每次Minor GC会清理年轻代的内存)
  2. 因为Java对象大多都具备朝生夕灭的特性,所以Minor GC非常频繁,一般回收速度也比较快。这一定义既清晰又易于理解。
  3. Minor GC会引发STW(Stop The World),暂停其它用户的线程,等垃圾回收结束,用户线程才恢复运行

3.3 Major/Full GC

老年代GC(MajorGC)触发机制

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

Full GC 触发机制(后面细讲)

触发Full GC执行的情况有如下五种:

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

说明:Full GC 是开发或调优中尽量要避免的。这样STW时间会短一些

3.4 GC日志分析

public static void main(String[] args) {
    int i = 0;
    try {
        List<String> list = new ArrayList<>();
        String a = "mahaonan";
        while (true) {
            list.add(a);
            a = a + a;
            i++;
        }
    } catch (Throwable t) {
        t.printStackTrace();
        System.out.println("遍历次数为:" + i);
    }
}

设置运行参数: -Xms9m -Xmx9m -XX:+PrintGCDetails

1. [GC (Allocation Failure) [PSYoungGen: 2048K->498K(2560K)] 2048K->1078K(9728K), 0.0006549 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
2. [GC (Allocation Failure) [PSYoungGen: 2504K->512K(2560K)] 3084K->1611K(9728K), 0.0006004 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
3. [GC (Allocation Failure) [PSYoungGen: 2301K->512K(2560K)] 3400K->2539K(9728K), 0.0005295 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
4. [Full GC (Ergonomics) [PSYoungGen: 1698K->0K(2560K)] [ParOldGen: 7147K->5553K(7168K)] 8846K->5553K(9728K), [Metaspace: 3309K->3309K(1056768K)], 0.0028713 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
5. [GC (Allocation Failure) [PSYoungGen: 0K->0K(2560K)] 5553K->5553K(9728K), 0.0001951 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
6. [Full GC (Allocation Failure) [PSYoungGen: 0K->0K(2560K)] [ParOldGen: 5553K->5485K(7168K)] 5553K->5485K(9728K), [Metaspace: 3309K->3309K(1056768K)], 0.0048964 secs] [Times: user=0.01 sys=0.00, real=0.01 secs] 
遍历次数为:16
Heap
 PSYoungGen      total 2560K, used 71K [0x00000000ffd00000, 0x0000000100000000, 0x0000000100000000)
  eden space 2048K, 3% used [0x00000000ffd00000,0x00000000ffd11d10,0x00000000fff00000)
  from space 512K, 0% used [0x00000000fff80000,0x00000000fff80000,0x0000000100000000)
  to   space 512K, 0% used [0x00000000fff00000,0x00000000fff00000,0x00000000fff80000)
 ParOldGen       total 7168K, used 5485K [0x00000000ff600000, 0x00000000ffd00000, 0x00000000ffd00000)
  object space 7168K, 76% used [0x00000000ff600000,0x00000000ffb5b600,0x00000000ffd00000)
 Metaspace       used 3344K, capacity 4496K, committed 4864K, reserved 1056768K
  class space    used 360K, capacity 388K, committed 512K, reserved 1048576K
java.lang.OutOfMemoryError: Java heap space
	at java.util.Arrays.copyOfRange(Arrays.java:3664)
	at java.lang.String.<init>(String.java:207)
	at java.lang.StringBuilder.toString(StringBuilder.java:407)
	at jvm.heap.GCTest.main(GCTest.java:20)

解释如下:

1发生了一次YGC,PSYoungGen: 2048K->498K(2560K) -> 年轻代总空间为2560k,当前占用2048k,经过垃圾回收剩余498k;2048K->1078K(9728K) -> 堆内总空间为9728k,当前占用2048k,经过回收后剩余1078K

4发生了一次FullGC,[PSYoungGen: 1698K->0K(2560K)] [ParOldGen: 7147K->5553K(7168K)] 8846K->5553K(9728K),年轻代回收后变为0K,老年代变为5553K,堆内总空间剩余5553K

四. 参数设定

官方文档https://docs.oracle.com/javase/8/docs/technotes/tools/unix/java.html

4.1 常用参数

/**
 * 测试堆空间常用的jvm参数:
 * -XX:+PrintFlagsInitial : 查看所有的参数的默认初始值
 * -XX:+PrintFlagsFinal  :查看所有的参数的最终值(可能会存在修改,不再是初始值)
 *      具体查看某个参数的指令: jps:查看当前运行中的进程
 *                             jinfo -flag SurvivorRatio 进程id
 *
 * -Xms:初始堆空间内存 (默认为物理内存的1/64)
 * -Xmx:最大堆空间内存(默认为物理内存的1/4)
 * -Xmn:设置新生代的大小。(初始值及最大值)
 * -XX:NewRatio:配置新生代与老年代在堆结构的占比
 * -XX:SurvivorRatio:设置新生代中Eden和S0/S1空间的比例
 * -XX:MaxTenuringThreshold:设置新生代垃圾的最大年龄
 * -XX:+PrintGCDetails:输出详细的GC处理日志
 * 打印gc简要信息:① -XX:+PrintGC   ② -verbose:gc
 * -XX:HandlePromotionFailure:是否设置空间分配担保
 */

4.2 空间分配担保

1、在发生Minor GC之前,虚拟机会检查老年代最大可用的连续空间是否大于新生代所有对象的总空间。

  • 如果大于,则此次Minor GC是安全的
  • 如果小于,则虚拟机会查看**-XX:HandlePromotionFailure**设置值是否允担保失败。
    • 如果HandlePromotionFailure=true,那么会继续检查老年代最大可用连续空间是否大于历次晋升到老年代的对象的平均大小
      • 如果大于,则尝试进行一次Minor GC,但这次Minor GC依然是有风险的;
      • 如果小于,则进行一次Full GC。
    • 如果HandlePromotionFailure=false,则进行一次Full GC。

历史版本

  1. 在JDK6 Update 24之后,HandlePromotionFailure参数不会再影响到虚拟机的空间分配担保策略,观察openJDK中的源码变化,虽然源码中还定义了HandlePromotionFailure参数,但是在代码中已经不会再使用它。
  2. JDK6 Update 24之后的规则变为只要老年代的连续空间大于新生代对象总大小或者历次晋升的平均大小就会进行Minor GC,否则将进行Full GC。即 HandlePromotionFailure=true

五. 深入理解

使用逃逸分析,编译器可以对代码做如下优化:

  1. 栈上分配:将堆分配转化为栈分配。如果一个对象在子程序中被分配,要使指向该对象的指针永远不会发生逃逸,对象可能是栈上分配的候选,而不是堆上分配
  2. 同步省略:如果一个对象被发现只有一个线程被访问到,那么对于这个对象的操作可以不考虑同步。
  3. 分离对象或标量替换:有的对象可能不需要作为一个连续的内存结构存在也可以被访问到,那么对象的部分(或全部)可以不存储在内存,而是存储在CPU寄存器中。

5.1 栈上分配

  1. JIT编译器在编译期间根据逃逸分析的结果,发现如果一个对象并没有逃逸出方法的话,就可能被优化成栈上分配。分配完成后,继续在调用栈内执行,最后线程结束,栈空间被回收,局部变量对象也被回收。这样就无须进行垃圾回收了。
  2. 常见的栈上分配的场景:在逃逸分析中,已经说明了,分别是给成员变量赋值、方法返回值、实例引用传递。

5.2 同步省略

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

例如下面的代码

public void f() {
    Object hollis = new Object();
    synchronized(hollis) {
        System.out.println(hollis);
    }
}

代码中对hollis这个对象加锁,但是hollis对象的生命周期只在f()方法中,并不会被其他线程所访问到,所以在JIT编译阶段就会被优化掉,优化成:

public void f() {
    Object hellis = new Object();
    System.out.println(hellis);
}

5.3 标量替换

分离对象或标量替换

  1. 标量(scalar)是指一个无法再分解成更小的数据的数据。Java中的原始数据类型就是标量。
  2. 相对的,那些还可以分解的数据叫做聚合量(Aggregate),Java中的对象就是聚合量,因为他可以分解成其他聚合量和标量。
  3. 在JIT阶段,如果经过逃逸分析,发现一个对象不会被外界访问的话,那么经过JIT优化,就会把这个对象拆解成若干个其中包含的若干个成员变量来代替。这个过程就是标量替换。
public static void main(String args[]) {
    alloc();
}
private static void alloc() {
    Point point = new Point(1,2);
    System.out.println("point.x" + point.x + ";point.y" + point.y);
}
class Point {
    private int x;
    private int y;
}

以上代码,经过标量替换后,就会变成

private static void alloc() {
    int x = 1;
    int y = 2;
    System.out.println("point.x = " + x + "; point.y=" + y);
}
  1. 可以看到,Point这个聚合量经过逃逸分析后,发现他并没有逃逸,就被替换成两个聚合量了。
  2. 那么标量替换有什么好处呢?就是可以大大减少堆内存的占用。因为一旦不需要创建对象了,那么就不再需要分配堆内存了。
  3. 标量替换为栈上分配提供了很好的基础。

标量替换参数设置

参数 -XX:+ElimilnateAllocations:开启了标量替换(默认打开),允许将对象打散分配在栈上。

举例说明

public class ScalarReplace {

    public static class User {
        public int id;
        public String name;
    }

    public static void alloc() {
        User u = new User();//未发生逃逸
        u.id = 5;
        u.name = "mahaonan";
    }

    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        for (int i = 0; i < 10000000; i++) {
            alloc();
        }
        long end = System.currentTimeMillis();
        System.out.println("花费的时间为: " + (end - start) + " ms");
    }
}

如果关闭标量替换:-Xmx100m -Xms100m -XX:+DoEscapeAnalysis -XX:+PrintGC -XX:-EliminateAllocations

花费的时间为: 32 ms

如果开启标量替换:-Xmx100m -Xms100m -XX:+DoEscapeAnalysis -XX:+PrintGC -XX:+EliminateAllocations

默认情况下是开启的

花费的时间为: 3 ms