JVM05_堆的概述、内存结构、复制算法、Minor|Major|Full GC、私有区域TLAB、对象分配、参数总结、逃逸分析、栈上分配、锁消除、标量替换

①. 堆的概述(共享|垃圾回收)

• ①. 一个JVM实例只存在一个堆内存,堆也是Java内存管理的核心区域

• ②. 堆可以在物理上不连续的内存空间中,但在逻辑上是连续的

• ③. Java堆区在JVM启动的时候即被创建,其空间大小也是确定的。是Jvm管理最大的一块内存空间

• ④. 所有的线程共享Java堆,在这里还可以划分线程私有的缓冲区(Thread Local Allocation Buffer,TLAB)

• ⑤. 在方法结束后,堆中的对象不会马上被移除,仅仅在垃圾收集的时候才有被移除
  (注意:一个进程就是一个JVM实例,一个进程中包含多个线程)

• ⑥. 举例

public class SimpleHeap {
    private int id;

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

    public void show() {
        System.out.println("My ID is " + id);
    }

    public static void main(String[] args) {
        SimpleHeap sl = new SimpleHeap(1);
        SimpleHeap s2 = new SimpleHeap(2);
    }
}

②. 堆的内存结构

• ①. 现在垃圾收集器大部分都基于分带收集理论设计的,堆空间细分为:
  

• ②. jdk1.7 堆中的结构
  

• ③. jdk 1.8 堆中的结构
  

③. 堆空间大小的设置 -Xms -Xmx

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

• ②. -Xms(物理内存的1/64):表示堆区的起始内存,等价于-XX:InitialHeapSize

• ③. -Xmx(物理内存的1/4):则用于表示堆区的最大内存,等价于-XX:MaxHeapSize

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

• ⑤. 案列演示

package com.xiaozhi.heap;

import java.util.concurrent.TimeUnit;

/**
 * -Xms:600m
 * -Xmx:600m
 * 查看设置的参数:
 * 方式一(cmd中):jps  / jstat -gc 进程id
 * 方式二(XX:+PrintGCDetails)
 */
public class HeapDemo1 {
    public static void main(String[] args)throws Exception {
        //返回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");
        //TimeUnit.SECONDS.sleep(1000000);
    }
}

④. 新生代与老年代参数设置 NewRation SurvivorRatio

• ①. 配置新生代与老年代在堆结构占比
  默认:-XX:NewRatio=2,表示新生代占1,老年代占2,新生代占整个堆的1/3
  可以修改-XX:NewRatio=4,表示新生代占1,老年代占4,新生代占整个堆的1/5
  

• ②. -XX:SurvivorRatio调整这个空间比例(Eden空间和另外两个Survivor空间缺省所占的比例是8:1:1)

• ③. -Xmn:设置新生代最大内存大小,一般使用默认值就可以了

• ④. 几乎所有的Java对象都是在Eden区被new出来的,觉大部分的Java对象的销毁都在新生代进行的

⑤. 复制算法

• ①. 一般过程(图解)
  
  
• ②. 复制算法详解 掌握
  (伊甸园满了,就会触发gc(minor gc),而gc就会把标识为垃圾的对象干掉,不是垃圾的对象就要转移到幸存区,把伊甸园让出来给新的对象用)

过程:

⑥. Minor GC | Major GC | Full GC

• ①. YONG GC(minor GC):发生在新生代

1. 只针对新生代区域的GC,指发生在新生代的垃圾收集动作,因为大多数Java对象存活率都不高,所以Minor GC非常频繁,一般回收速度也比较快
2. 当Eden代满,会触发minor GC ,Survivor 满不会引发GC
3. minor gc 会引发STW,暂停其他用户线程,等垃圾回收结束,用户线程才能恢复

• ②. Major GC:发生在老年代
  major GC 是回收老年代的垃圾；major gc 的速度一般比Minor gc 慢10倍以上,STW时间更长

• ③. Full GC:发生在新生代和老年代

1. full GC 就会出现所谓的STW(stop the world)现象,即所有的进程都挂起等待清理垃圾
2. full GC是回收老年代和年轻代的垃圾
3. full gc 是开发调优中尽量避免的,这样暂时时间会短一些

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

• ④. 全局GC(major GC or Full GC):
  (指发生在老年代的垃圾收集动作,出现了Major GC,经常会伴随至少一次的Minor GC(但并不是绝对的)。Major GC的速度一般要比Minor GC慢上10倍以上)

⑦. 针对不同年龄阶段的对象分配原则

• ①. 优先分配到Eden

• ②. 大对象直接分配到老年(尽量避免程序中出现过多的大对象)

• ③. 长期存活的对象分配到老年代

• ④. 动态对象年龄判断
  (如果Survivor 区中相同年龄的所有对象大小的总和大于Survivor空间的一半,年龄大于或等于该年龄对象可以直接进入老年代,无须等到MaxTenurningThreshold中要求的年龄)

• ⑤. 空间分配担保 -XX:HandlePromotionFailure
  (JDK6之后,只要老年代的连续空间大于新生代对象总大小或者历次晋升的平均大小就会进行Minor GC,否则将进行Full GC)

⑧. TLAB(Thread Local Allocation Buffer)

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

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

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

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

• ⑤. 图解:
  
  

⑨. 堆空间参数总结

• ①. -XX:+PrintFlagsInitial : 查看所有的参数的默认初始值

• ②. -XX:+PrintFlagsFinal : 查看所有的参数的最终值(可能会存在修改(:表示修改了),不再是初始值)

• ③. 具体查看某个参数的指令:
  (jps:查看当前运行中的进程
  jinfo -flag SurvivorRatio 进程id)

• ④. -Xms:初始堆空间内存 (默认为物理内存的1/64)

• ⑤. -Xmx:最大堆空间内存(默认为物理内存的1/4)

• ⑥. -Xmn:设置新生代的大小。(初始值及最大值)

• ⑦. -XX:NewRatio:配置新生代与老年代在堆结构的占比
  (默认:-XX:NewRatio=2,表示新生代占1,老年代占2,新生代占整个堆的1/3
  可以修改-XX:NewRatio=4,表示新生代占1,老年代占4,新生代占整个堆的1/5)

• ⑧. -XX:SurvivorRatio:设置新生代中Eden和S0/S1空间的比例
  (Eden空间和另外两个Survivor空间缺省所占的比例是8:1:1)

• ⑨. -XX:MaxTenuringThreshold:设置新生代垃圾的最大年龄

• ⑩. -XX:+PrintGCDetails:输出详细的GC处理日志
  (如下这两种方式是简单的打印
  打印gc简要信息:① -XX:+PrintGC ② -verbose:gc)

• ⑩①. -XX:HandlePromotionFailure:是否设置空间分配担保
  (JDK6之后,只要老年代的连续空间大于新生代对象总大小或者历次晋升的平均大小就会进行Minor GC,否则将进行Full GC)

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

⑩. 逃逸分析

• ①. 如何将堆上的对象分配到栈,需要使用逃逸分析手段

1. 当一个对象在方法中被定义后,对象只在方法内部使用(这里关注的是这个对象的实体),则认为没有发生逃逸。
2. 当一个对象在方法中被定义后,它被外部方法所引用,则认为发生逃逸。例如作为调用参数传递到其他地方中

• ②. 代码演示

//(1). 没有发生逃逸的对象,则可以分配到栈上,随着方法执行的结束,栈空间就被移除
public void my_method() {
    V v = new V();
    // use v
    // ....
    v = null;
}
//(2). 下面代码中的 StringBuffer sb 发生了逃逸
public static StringBuffer createStringBuffer(String s1, String s2) {
    StringBuffer sb = new StringBuffer();
    sb.append(s1);
    sb.append(s2);
    return sb;
}
//如果想要StringBuffer sb不发生逃逸,可以这样写
public static String createStringBuffer(String s1, String s2) {
    StringBuffer sb = new StringBuffer();
    sb.append(s1);
    sb.append(s2);
    return sb.toString();
}

• ③. 逃逸分析的举例

/**
 * 逃逸分析
 *
 * 如何快速的判断是否发生了逃逸分析,大家就看new的对象实体是否有可能在方法外被调用。
 */
public class EscapeAnalysis {

    public EscapeAnalysis obj;

    /*
    方法返回EscapeAnalysis对象,发生逃逸
     */
    public EscapeAnalysis getInstance(){
        return obj == null? new EscapeAnalysis() : obj;
    }

    /*
    为成员属性赋值,发生逃逸
     */
    public void setObj(){
        this.obj = new EscapeAnalysis();
    }
    //思考:如果当前的obj引用声明为static的？ 仍然会发生逃逸。

    /*
    对象的作用域仅在当前方法中有效,没有发生逃逸
     */
    public void useEscapeAnalysis(){
        EscapeAnalysis e = new EscapeAnalysis();
    }

    /*
    引用成员变量的值,发生逃逸
    
     */
    public void useEscapeAnalysis1(){
        EscapeAnalysis e = getInstance(); //这个e对象,本身就是从外面的方法逃逸进来的
        //getInstance().xxx()同样会发生逃逸
    }
}

• ④. 在JDK1.7版本之后,HotSpot中默认就已经开启了逃逸分析
  如果使用的是较早的版本,开发人员则可以通过:
  选项“-XX:+DoEscapeAnalysis"显式开启逃逸分析
  通过选项“-XX:+PrintEscapeAnalysis"查看逃逸分析的筛选结果

• 结论: ⑤. 开发中能使用局部变量的,就不要使用在方法外定义

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

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

⑩①. 栈上分配

• ①. JIT编译器在编译期间根据逃逸分析的结果,发现如果一个对象并没有逃逸出方法的话,就可能被优化成栈上分配

• ②.代码举例

/**
 * 栈上分配测试
 * -Xmx256m -Xms256m -XX:-DoEscapeAnalysis -XX:+PrintGCDetails
 */
public class StackAllocation {
    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");
        // 为了方便查看堆内存中对象个数,线程sleep
        try {
            Thread.sleep(1000000);
        } catch (InterruptedException e1) {
            e1.printStackTrace();
        }
    }

    private static void alloc() {
        User user = new User(); //未发生逃逸
    }

    static class User {

    }
}

• ③. 未开启逃逸分析的情况
  -Xmx256m -Xms256m -XX:-DoEscapeAnalysis -XX:+PrintGCDetails

日志打印发生了GC
[GC (Allocation Failure) [PSYoungGen: 65536K->560K(76288K)] 65536K->568K(251392K), 0.0017179 secs] [Times: user=0.01 sys=0.00, real=0.00 secs] 
[GC (Allocation Failure) [PSYoungGen: 66096K->464K(76288K)] 66104K->480K(251392K), 0.0017602 secs] [Times: user=0.00 sys=0.00, real=0.01 secs] 
花费的时间为: 74 ms

• ④. 开启逃逸分析的情况
  -Xmx256m -Xms256m -XX:+DoEscapeAnalysis -XX:+PrintGCDetails

日志打印:并没有发生 GC,耗时 3ms ,栈上分配是真的快啊
花费的时间为: 4 ms

⑩②. 同步替换 锁消除

• ①. 从JIT角度看相当于无视它了,这个锁对象没有被共享给其他线程

• ②. 例如下面的智障代码,根本起不到锁的作用
  代码中对hellis这个对象加锁(每个线程都有一个hellis对象的锁),但是hellis对象的生命周期只在f( )方法中,并不会被其他线程所访问到,所以在JIT编译阶段就会被优化掉,优化成:

public void f() {
    Object hellis = new Object();
    synchronized(hellis) {
        System.out.println(hellis);
    }
}
// JIT会将它变成这样
public void f() {
  	Object hellis = new Object();
		System.out.println(hellis);
}

• ③. 注意:字节码文件中并没有进行优化,可以看到加锁和释放锁的操作依然存在,同步省略操作是在解释运行时发生的
  

⑩③. 分离对象或标量替换

• ①. 标量(scalar)是指一个无法再分解成更小的数据的数据。Java中的原始数据类型就是标量

• ②. 相对的,那些还可以分解的数据叫做聚合量(Aggregate),Java中的对象就是聚合量,因为他可以分解成其他聚合量和标量

• ③. 在JIT阶段,如果经过逃逸分析,发现一个对象不会被外界访问的话,那么经过JIT优化,就会把这个对象拆解成若干个其中包含的若干个成员变量来代替。这个过程就是标量替换

• ④. 举列子

public static void main(String args[]) {
    alloc();
}
class Point {
    private int x;
    private int y;
}
private static void alloc() {
    Point point = new Point(1,2);
    System.out.println("point.x" + point.x + ";point.y" + point.y);
}
//以上代码,经过标量替换后,就会变成
private static void alloc() {
    int x = 1;
    int y = 2;
    System.out.println("point.x = " + x + "; point.y=" + y);
}