JVM篇-堆空间（Heap）

堆的核心概述

1. 一个JVM实例只存在一个堆内存，堆也是Java内存管理的核心区域
2. Java堆区在JVM启动的时候既被创建，其空间到校也就确定了，是JVM管理的最大一块内存空间（堆内存可以调节）
3. 《Java虚拟机规范》规范，对可以处于物理上不连续的内存空间中，但在逻辑上它应该被视为连续的
4. 所有的线程共享Java堆，在这里还可以划分线程私有的缓冲区（Thread Local Allocation Buffer,TLAB）
5. （几乎）所有的对象实例以及数组都应当在运行时分配在堆上。
6. 数组和对象可能永远刽存储在栈上，因为栈帧中保存引用，这个引用指向对象或者数组在堆中的位置。
7. 在方法结束后，堆中的对象不会马上被已出货，仅仅在垃圾收集的时候才会被溢出
8. 堆，是GC(Garbage Collection ==>垃圾收集器) 执行垃圾回收的重点区域。（仅有方法区与堆中有GC）
   

内存细分

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

Java 8以及之后的堆内存逻辑上分为：新生区+养老区+元空间

设置堆内存的大小与OOM

堆空间的大小设置

	-Xms //用于表示堆空间的起始内存（泛指年轻代与老年代），等价 -XX:InitialHeapSize
	-Xmx //用于表示堆区的最大内存 -XX:MaxHeapSize
----------------------------------------------
/**
 * 1. 设置堆空间大小的参数
 * -Xms 用来设置堆空间（年轻代+老年代）的初始内存大小
 *      -X 是jvm的运行参数
 *      ms 是memory start
 * -Xmx 用来设置堆空间（年轻代+老年代）的最大内存大小
 *
 * 2. 默认堆空间的大小
 *    初始内存大小：物理电脑内存大小 / 64
 *             最大内存大小：物理电脑内存大小 / 4
 * 3. 手动设置：-Xms600m -Xmx600m
 *     开发中建议将初始堆内存和最大的堆内存设置成相同的值。
 *
 * 4. 查看设置的参数：方式一： jps   /  jstat -gc 进程id
 *                  方式二：-XX:+PrintGCDetails

查看堆内存占用情况

OOM异常

import java.util.ArrayList;
import java.util.Random;

/**
 * -Xms600m -Xmx600m
 * @author shkstart  shkstart@126.com
 * @create 2020  21:12
 */
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];
    }
}

年轻代老年代

JVM中的Java对象可以划分两类（从生命周期划分）

1. 一类是生命周期较对的瞬时对象，这类对象的创建和小王都是迅速的
2. 另一类对象的生命周期非常长，在某些极端的情况下还能够JVM的生命周期一致

Java堆区进一步花费可分为
年轻代（YoungGen）
年轻代可以划分为
Eden（伊甸园）空间
Survivor 0空间(From区)
Survivor 1空间(To区)
老年代(OldGen)

关于这个新生代参数的设置

 -Xms600m -Xmx600m

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

对象分配过程

1. new 的对象先放在伊甸园区(Eden)这个区域有大小限制===>因此只有这里有OOM异常
2. 当一点远去的空间填满时,触发Minor GC,进行垃圾回收
3. 将伊甸园中剩余对象移动到幸存者0区
4. 在此触发垃圾回收,此时幸存者0区的对象还是或者那么就会方法幸存者1区
5. 如果在此精力垃圾回收,此时会重新放回幸存者0区,接着再去1区
6. 什么时候进入养老区呢?可以设置次数,默认阈值是15(既age=15,在0区1区反复横跳15次之后)
	也可用过参数设阈值 -XX:MaxTenurigThreshold=<N>

总结

针对这个幸存者s0,s1的总结:

复制之后有交换,谁空谁是to区

关于垃圾回收

频繁的在新生区收集,很少在养老区收集,几乎不去永久区/元空间收集

对象分配的特殊情况

Minor GC Major GC Full GC

JVM进行GC时,并不是针对上面三个内存区域(新生代,老年代,方法区)一起回收的

HotSpot VM GC按照回收区域又分为两大类型

部分收集(Partial GC)

新年代收集(Minor GC/Young GC):只是新生代的垃圾回收
老年代收集(Major GC/Old GC):只是老年代的垃圾收集

	 目前只有CMS GC会有单独收集老年代的行为
	 注意:Major GC只是老年代的垃圾收集,不能Full GC混淆使用.需要具体分辨是老年代回收还是值整堆回收

混合收集(Mixed GC) :收集整个新生代以及部分老年代的垃圾收集

	目前,只有G1 GC会有这种行为

整堆收集(Full GC)

	收集整个java堆和方法区的垃圾收集

垃圾回收GC触发机制

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

当年轻代内存不足时,就会触发Minor GC 这里年轻代是指Eden(伊甸园)代满了 , Survivor满了不会触发GC
Java大多对象具有朝生夕死的特性,因此Minor GC是频繁的,一般回收速度也比较快
Minor GC会触发STW,暂停其他用户的线程,等垃圾回收结束,用户线程才能恢复运行

老年代GC(Major GC/Full GC)触发机制

1. 值发生在老年代的GC,对象从老年代小时,便可以说Major GC 或者 Full GC触发了
2. 出现了Major GC 经常会伴随至少一次的Minor GC(不绝对,在Parallel Scavenge 收集器的收集策略就有直接进行Major GC 的策略选择过程)
3.  Major GC的速度一般会比Minor GC 慢10倍以上,因此STW时间更长
4. 如果Major GC后,内存还不足就会报OOM异常

Full GC触发机制(五种情况)

1. 调用System.gc()时,系统建议执行Full GC 不必然你执行
2. 老年代空间不足
3. 方法区空间不足
4. Minor GC后进入老年代的平均大小>老年代的可用内存
5. Eden区,survivor space 0 (From Space)区向survivor space 1(To Space)区赋值时 对象大小大于To Space可用内存,就会吧这个对象转存到老年代,且老年代的可用内存小于该对象的大小

要避免full gc 是开发调优中要避免的 这样STW时间会短一点

堆空间的分代思想

为什么需要把Java堆分代?不分代就不能正常工作了吗?

因为Java的对象70%-99%都是朝生夕死的 分代可以优化GC的一个性能问题

内存分配策略(对象提升规则(Promotion))

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

1. 优先分配到Eden
2. 大对象直接分配到老年代(尽量避免程序中过多大对象)
3. 长期存活的对象分配到老年代
4. 动态对象年龄判断
   若S区所有对象的大小的总和大于S区空间的一半 其年龄>=该年龄对象可就直接进入老年代,不需要等到阈值(默认15)
5. 空间分配担保
   -XX:HandlePromottionFailure

为对象分配内存 TLAB

为什么有TLAB?

1. 堆空间是线程共享区域 任何线程都可以访问到堆区的共享数据
2. 由于对象实例的创建在JVM中非常平凡,因此开发坏境下从堆区中花费内存空间是线程不安全的
3. 为了便面多个线程操作同一个地址,需要采用加锁的策略,进而影响分配速度
   什么是TLAB?
   
4. 从内存模型的角度看,JVM为每个线程分配了一个私有缓存区域,包含Eden空间内
5. 多线程同事分配内存是,使用TLAB可以避免一些列的非下层安全问题,同事还能提升内存分配的吞吐量,因此我们将这种内存分配方式成为快速分配策略
   6.所有 Open JDK 衍生的JVM都提供了TLAB
6. JVM将TLAB作为内存分配的首选
7. -XX:UserTLAB 设置开启TLAB空间
8. 默认TLAB的内存很小,仅有Eden空间的1%
9. JVM分配内存失败,JVM会尝试通过加锁进制确保数据操作的原子性
   

小结堆空间的参数设置

/**
 * 测试堆空间常用的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：是否设置空间分配担保
 *
 */
public class HeapArgsTest {
    public static void main(String[] args) {

    }
}

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

随着JIT编译器的发展与逃逸分析技术逐渐成熟,栈上分配与标量替换优化技术会导致一些微妙的变化,所有对象都分配到对上也逐渐不那么绝对了

如果经过====>逃逸分析(Escape Analysis)后发现,一个对象并没有逃逸出去方法的话,那么就可能被优化成栈上分配

逃逸分析概述

• 想要把堆上的对象分配到栈,需要使用逃逸分析手段
• 这是一种可以有效的减少Java 程序中同步负载和内存堆分配压力的跨函数全局数据流分析算法
• 同过逃逸分析,Java HotSpot编译器能够分析出一个新的对象的引用的使用范围从而决定是否要讲这个对象分配到堆上.
• 逃逸分析的基本行为就是分析对象动态的作用域

1.  当一个对象在方法中被定义后,**对象只在方法内部使用,**则**认为没有发生逃逸** 
   

2. 当一个对象在方法中被定义后,它被外部方法所引用,则认为发生逃逸,例如作为调用参数传递到其他方法中

/**
 * 逃逸分析
 *
 *  如何快速的判断是否发生了逃逸分析，大家就看new的对象实体是否有可能在方法外被调用。
 * @author shkstart
 * @create 2020 下午 4:00
 */
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();
        //getInstance().xxx()同样会发生逃逸
    }
}

结论

开发中能使用局部变量的,就不要使用方法外定义

基于逃逸分析之代码优化策略

1. 栈上分配策略

• JIT编译器在编译期间根据逃逸分析的结果,发现:
• 若一个对象没有逃逸出方法的话就可能被优化成栈上分配.
• 分配完成就继续在调用栈内执行,最后线程结束,栈空间呗回收,局部变量对象也被回收,这样就不需要进行垃圾回收了

常见栈上分配的场景

1. 给成员变量赋值
2. 方法返回值
3. 实例引用传递

package com.atguigu.java2;

/**
 * 栈上分配测试
 * -Xmx1G -Xms1G -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 {

    }
}

大家可以看到这个是开启逃逸分析的效果(JDK7(确切来说JDK6_23)以后是默认开启逃逸分析)
执行时间是5毫秒

那我们来看看不开启逃逸分析的结果

执行时间是113毫秒 可见优化以后的性能是大有提升的

同步省略(锁消除)

	 如果一个对象被发现只能从一个线程被访问到 那么对于这个对象的操作者可以不考虑同步

• 线程同步代价是相当高的,同步的后果是降低并发性和性能
• JIT可以借助逃逸分析来判断同步快锁使用的锁对象是否能够被一个线程锁访问而没有被发布到其他线程

标量替换(分离对象)

====>有的对象可能不需要作为一个连续的内存结构存在也可以被访问到 
====>那么对象的部分(或者全部)可以不存在内存 而是存在CPU的寄存器里

标量(Scalar)

===>无法在分解成更小的数据的数据
如Java中的原始数据类型就是标量

聚合量(Aggregate)

可以分解的数据叫聚合量
如Java对象

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

/**
 * 标量替换测试
 *  -Xmx100m -Xms100m -XX:+DoEscapeAnalysis -XX:+PrintGC -XX:-EliminateAllocations
 */
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 = "www.atguigu.com";
    }

    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");
    }
}

/*
class Customer{
    String name;
    int id;
    Account acct;

}

class Account{
    double balance;
}


 */