第 7 章一堆的概述、年轻代与老年代、分代收集、堆空间常用参数设置、对象分配过程、堆空间分代思想、栈上分配(逃逸分析、标量替换、同步省略)

左手的ㄟ右手 2022-12-28 09:06 80阅读 0赞

# 第 7 章 堆 #

## 1、堆的核心概述 `(重点)` ##

> 堆空间的一些参数:
> 
>  *  \-Xms10m -Xmx10m 设置堆的最小/最大空间.(一般我们设置成相同的)
>  *  \-XX:+PrintGCDetails 显示GC的日志
>  *  \-XX:NewRatio ： 设置新生代与老年代的比例。默认值是2.
>  *  \-XX:SurvivorRatio ：设置新生代中Eden区与Survivor区的比例。默认值是8
>  *  \-XX:MaxTenuringThreshold : 用于设置年轻代晋升到老年代的年龄阈值. 默认为15

### 1.1、认识堆内存 ###

> **堆与进程**

1.  `堆`针对一个`JVM进程`来说是`唯一`的，也就是**一个进程只有一个JVM**
2.  但是**进程包含多个线程，`线程是共享同一堆空间`的**

![image-20200706195127740][]

> **对堆的认识**
> 
>  *  堆是线程共享的资源.

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`的时候，才会进行`回收`
     *  如果**堆中对象马上被回收，那么用户线程就会收到影响(因为频繁进行GC, 用户线程可能会暂停, 出现卡顿现象)**，因为有`stop the word (暂停用户线程, STW越少越好)`
9.  **`堆，是GC（Garbage Collection，垃圾收集器）执行垃圾回收的重点区域。`**

![image-20200706201904057][]

> **`一个JVM实例只存在一个堆内存，并且堆内存的大小是可以调节的`**

**`如何设置堆内存大小 :`**

*  进程1

-Xms10m -Xmx10m

![image-20200728203845527][]

*  进程 2

-Xms20m -Xmx20m

![image-20200728203928284][]

### 1.2、查看堆内存 ###

**使用 JDK 自带的工具：`Java VisualVM` ，`来查看堆内存`**

*  Java VisualVM 在 JDK 的 bin 目录下

![image-20200728204013940][]

*  进程 1 ：`堆内存为 10 M`

![image-20200728204217567][]

*  进程 2 ：`堆内存为 20 M`

![image-20200728204241292][]

> **代码示例**

*  代码

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);
            int[] arr = new int[10];
            Object[] arr1 = new Object[10];
        }
    }

*  **字节码指令**  
    ![image-20200728210007805][]

### 1.3、堆内存分区 `(重点)` ###

> **堆内存细分 : `新生代 + 老年代 + 永久代(元空间)`**

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`

![image-20200706203419496][]

1.  约定：新生区 <–> 新生代 <–> 年轻代 、 养老区 <–> 老年区 <–> 老年代、 永久区 <–> 永久代
2.  堆空间内部结构，`JDK1.8之前从永久代 替换成 元空间`

![image-20200706203835403][]

> **Java VisualVM 查看堆内存**

*  安装 Visual GC

![image-20200728211208333][]  
![image-20200728211229103][]

*  看：`新生代、老年代、元空间`

![image-20200728211403370][]

--------------------

## 2、设置堆内存大小与 OOM `(重点)` ##

### 2.1、设置堆内存 ###

> **设置堆空间大小**

1.  `Java堆区`用于`存储Java对象实例`，**那么堆的大小在JVM启动时就已经设定好了**，大家可以通过选项`"-Xms"`和`"-Xmx"`来进行设置。
    
     *  **-Xms**用于`表示堆区的起始内存`，等价于 **-XX:InitialHeapSize**
     *  **-Xmx**用于`表示堆区的最大内存`，等价于 **-XX:MaxHeapSize**
2.  **一旦堆区中的内存大小超过“-Xmx"所指定的最大内存时 (在程序启动前,我们配置了-Xmx表示该程序的最大堆内存大小, 如果程序中我们超过了-Xmx设置的内存大小,此时就会报OOM)**，将会抛出`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

> **代码示例**

*  代码

/** * 1. 设置堆空间大小的参数 * -Xms 用来设置堆空间（年轻代+老年代）的初始内存大小 * -X 是jvm的运行参数 * ms 是memory start * -Xmx 用来设置堆空间（年轻代+老年代）的最大内存大小 * * 2. 默认堆空间的大小 * 初始内存大小：物理电脑内存大小 / 64 * 最大内存大小：物理电脑内存大小 / 4 * * 3. 手动设置：-Xms600m -Xmx600m * 开发中建议将初始堆内存和最大的堆内存设置成相同的值。 * * 4. 查看设置的参数：方式一： jps / jstat -gc 进程id * 方式二：-XX:+PrintGCDetails * @author shkstart shkstart@126.com * @create 2020 20:15 */
    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");
        }
    }

*  两种`查看堆内存的方式`
    
     *  方式一：命令行依次执行如下两个指令
        
         *  **`jps`**
         *  **`jstat -gc 进程id`**
     *  方式二：**设置虚拟机参数`-XX:+PrintGCDetails`**

注意: 为什么设置 600MB ，算出来只有 575MB 呢？

> 因为两个幸存者区, 他们采用的`复制`算法, 所以其中一个区域用来挪动存活对象使用的, 不会被占用

*  JVM 认为`幸存者 to 区 (也叫幸存者0区)`并**不存放对象（to区一直为空）**，所以没把它算上
 *  可以看到 `新生区的大小 = 伊甸园区大小 + 幸存者from区(幸存者1区)大小`
 *  即 179200KB = 153600KB + 25600KB

![image-20200728213547918][]

### 2.2、OOM 举例 ###

> **OOM举例**

*  代码

/** * -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)));
            }
        }
    }

*  设置虚拟机参数: `堆内存的大小`

-Xms600m -Xmx600m

*  监控堆内存变化：**Old 区域一点一点在变大，直到最后一次垃圾回收器无法回收垃圾时，堆内存被撑爆，抛出 OutOfMemoryError 错误**

![image-20200728214854972][]

*  堆内存变化图

![image-20200728224943553][]

*  分析原因：**大对象导致堆内存溢出: 当最后堆内存的容量容不下一个大对象了,此时就报OOM了**

![image-20200728214905013][]

--------------------

## 3、年轻代与老年代 ##

### 3.1、Java 对象分类 ###

> **Java 对象的分类**
> 
>  *  生命周期很短的, 生命周期长的

**存储在JVM中的Java对象可以被划分为两类：**

*  一类是生`命周期较短的瞬时对象`，**这类对象的创建和消亡都非常迅速**, 需要GC`及时回收`即可
 *  另一类`对象的生命周期非常长`，在某些极端的情况下还能够与JVM的生命周期保持一致

1.  Java堆区进一步细分的话，可以划分为 **`年轻代`**（YoungGen）和 **`老年代`**（oldGen）
2.  其中`年轻代`又可以划分为`Eden空间`、`Survivor0空间`和`Survivor1空间`（有时也叫做`from区、to区`）  
    ![image-20200707075847954][]

### 3.2、配置新老比例 ###

> **配置新生代与老年代的比例**
> 
>  *  默认:新生代占1, 老年代占2, 新生代占整个堆的 1/3
>  *  可通过`-XX:NewRatio=数值`来配置新老的比例

**配置新生代与老年代在堆结构的占比（一般不会调）**

1.  默认`-XX:NewRatio=2`，**表示新生代占1，老年代占2，新生代占整个堆的1/3**
2.  可以修改`-XX:NewRatio=4`，**表示新生代占1，老年代占4，新生代占整个堆的1/5**
3.  当发现在整个项目中，生命周期长的对象偏多，那么就可以通过调整老年代的大小，来进行调优

![image-20200707080154039][]

> **新生区中的比例**
> 
>  *  伊甸园区 : 幸存者0区 : 幸存者1区 = 8 : 1 : 1
>  *  几户所有的对象都是在伊甸园区被new出来的

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

> 该`年龄计数器`存放在对象的对象头`markword中`  
> ![image-20200707084208115][]

> **代码示例**

*  代码

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

*  通过命令行查看各种比例
    
     *  查看新生代与老年代的比例
        
            jps
            jinfo -flag NewRatios 进程id
     *  查看新生区中伊甸园区与幸存者区的比例
        
            jps
            jinfo -flag SurvivorRatio 进程id
 *  设置 JVM 参数

-Xms600m -Xmx600m -XX:SurvivorRatio=8

*  新生代中：`伊甸园区 : 幸存者 0 区 : 幸存者 1 区 = 8 : 1 : 1`
 *  `新生代 : 老年代 = 1 : 2`

从下图可以看出, 新生代总和占了`200M`, 老年代占了`400M`; 但新生代Eden(伊甸园区)占了`160M`, Survivor0,Survivor1各占了`20M`

**`注意:`新生代中的Survivor默认有一个是不会供我们使用的, 两个幸存者区他们使用的是`标记-复制`算法**  
![image-20200728221346507][]

--------------------

## 4、图解对象分配过程`(重点)` ##

### 4.1、对象分配过程 ###

> **对象分配过程**

**对象分配难点：**

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

**对象分配过程**

>  *  首先`new`的对象, 会先放到`伊甸园区`, 伊甸园区满的话, 此时会进行`MinorGC`对伊甸园区进行`垃圾回收`, 将`没有引用`的对象释放掉; 幸存下来的对象, 会被移动到`幸存者0`区;
>  *  当再次发生`MinorGC`的时候, 也会顺带对`幸存者区`进行回收, 此时MinorGC后, 会将伊甸园区的存活对象放到`幸存者1`区, `幸存者0`区原来存活的对象仍然存活, 此时也将它们移动到`幸存者1`区. 此时对象的年龄计数器(+1); 以此类推, 当在对象的`年龄计数器`到15的时候, 就会将该对象放到`老年代`。

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

### 4.2、图解对象分配 ###

> **图解对象分配过程**

*  我们`创建的对象`，一般都是`存放在Eden区`的，**当我们Eden区满了后，就会触发GC操作**，一般被称为 `YGC / Minor GC`操作  
    ![image-20200707084714886][]
 *  当我们`进行一次垃圾收集`后，红色的对象将会被回收，而绿色的独享还被占用着，存放在`S0(Survivor From)区`。同时我们给每个对象设置了一个`年龄计数器`，**经过一次回收后还存在的对象，将其年龄加 1。**
 *  同时`Eden区继续存放对象`，当Eden区再次存满的时候，又会触发一个`MinorGC`操作，**此时GC将会把 Eden和Survivor From中的对象进行一次垃圾收集**，`把存活的对象放到 Survivor To区，同时让存活的对象年龄 + 1`  
    ![image-20200707085232646][]
 *  我们继续不断的进行对象生成和垃圾回收，当`Survivor中的对象的年龄达到15`的时候，将会`触发一次 Promotion 晋升`的操作，也就是**将年轻代中的对象晋升到老年代**中

![image-20200707085737207][]

> **代码示例**

*  代码

/** * -Xms600m -Xmx600m * @author shkstart shkstart@126.com * @create 2020 17:51 */
    public class HeapInstanceTest { 
        byte[] buffer = new byte[new Random().nextInt(1024 * 200)];
    
        public static void main(String[] args) { 
            ArrayList<HeapInstanceTest> list = new ArrayList<HeapInstanceTest>();
            while (true) { 
                list.add(new HeapInstanceTest());
                try { 
                    Thread.sleep(10);
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
            }
        }
    }

*  注意【伊甸园区、幸存者区、老年区】的内存变化趋势

![image-20200728225824888][]

### 4.3、特殊情况说明 ###

> **思考：幸存区满了咋办？** : 不会触发YoungGC 或者 MinorGC, 只有伊甸园区满了才会触发YoungGc, 此时会顺带将幸存者区也GC
> 
>  *  幸存区满了, 只能将这些新对象晋升到老年代

1.  特别注意，在Eden区满了的时候，才会触发MinorGC，`而幸存者区满了后，不会触发MinorGC操作`。
2.  如果Survivor区满了后，将会触发一些特殊的规则，也就是可能直接晋升老年代

> **对象分配的特殊情况**

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

![image-20200707091058346][]

### 4.4、常用调优工具 ###

> **常用的 JVM 调优工具**

**常用调优工具**

1.  JDK命令行
2.  Eclipse：Memory Analyzer Tool
3.  `Jconsole`
4.  `Visual VM（实时监控）`
5.  `Jprofiler`
6.  `Java Flight Recorder（实时监控）`
7.  GCViewer
8.  GCEasy

**Jprofiler 基本使用**

*  在 IDEA 中启动 Jprofiler

![image-20200728230304833][]

*  点击 Instrumentation

![image-20200728230336191][]

*  选择默认配置即可，点击【OK】启动

![image-20200728230414510][]

![image-20200728230542338][]

> **总结**

1.  针对幸存者s0，s1区的总结：s0和s1使用的是`标记-复制算法`, 它们直接有交换，**谁空谁是to**
2.  关于垃圾回收：**`频繁在新生区收集`，`很少在老年代收集`，`几乎不在永久代和元空间进行收集`**
3.  **`新生代`采用`标记复制算法`的目的：是为了`减少内存碎片`**

--------------------

## 5、GC 垃圾回收器 `(重要)` ##

### 5.1、分代收集思想 ###

> **`Minor GC、Major GC、Full GC`**
> 
>  *  **MinorGC: 只清除新生代的垃圾**
>  *  **MajorGC: 只清除老年代的垃圾**
>  *  **FullGc: 对整个堆, 以及方法区的垃圾进行清除**

1.  `JVM的调优`的一个环节，也就是`垃圾收集`，我们需要`尽量的避免垃圾回收，因为在垃圾回收的过程中，容易出现STW（Stop the World）的问题`，**而 Major GC 和 Full GC出现`STW`的时间，是Minor GC的10倍以上**
2.  **JVM在进行GC时**，并非每次都对上面三个内存区域一起回收的，`大部分时候回收的都是指新生代`。针对Hotspot VM的实现，它里面的GC按照回收区域又分为两大种类型：**一种是部分收集（Partial GC），一种是整堆收集（FullGC）**

**分代收集：**

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

### 5.2、Young GC ###

> **年轻代 GC（Minor GC）触发机制**

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

![image-20200707095606813][]

### 5.3、Major/Full GC ###

> **老年代 GC（MajorGC/Full GC）触发机制**

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

> **Full GC 触发机制（后面细讲）**

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

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

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

> **GC 日志分析**

*  代码

/** * 测试MinorGC 、 MajorGC、FullGC * -Xms9m -Xmx9m -XX:+PrintGCDetails * * @author shkstart shkstart@126.com * @create 2020 14:19 */
    public class GCTest { 
        public static void main(String[] args) { 
            int i = 0;
            try { 
                List<String> list = new ArrayList<>();
                String a = "atguigu.com";
                while (true) { 
                    list.add(a);
                    a = a + a;
                    i++;
                }
    
            } catch (Throwable t) { 
                t.printStackTrace();
                System.out.println("遍历次数为：" + i);
            }
        }

*  JVM 参数

-Xms9m -Xmx9m -XX:+PrintGCDetails

*  GC 日志：`在 OOM 之前，一定会触发一次 Full GC ，因为只有在老年代空间不足时候，才会爆出OOM异常`

[GC (Allocation Failure) [PSYoungGen: 2020K->510K(2560K)] 2020K->812K(9728K), 0.0021339 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
    [GC (Allocation Failure) [PSYoungGen: 2550K->488K(2560K)] 2852K->2278K(9728K), 0.0005931 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
    [GC (Allocation Failure) [PSYoungGen: 1949K->504K(2560K)] 3740K->3062K(9728K), 0.0005918 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
    [Full GC (Ergonomics) [PSYoungGen: 1319K->0K(2560K)] [ParOldGen: 6782K->4864K(7168K)] 8102K->4864K(9728K), [Metaspace: 3452K->3452K(1056768K)], 0.0050464 secs] [Times: user=0.00 sys=0.00, real=0.01 secs] 
    [GC (Allocation Failure) [PSYoungGen: 0K->0K(2560K)] 4864K->4864K(9728K), 0.0003452 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
    [Full GC (Allocation Failure) [PSYoungGen: 0K->0K(2560K)] [ParOldGen: 4864K->4846K(7168K)] 4864K->4846K(9728K), [Metaspace: 3452K->3452K(1056768K)], 0.0061555 secs] [Times: user=0.00 sys=0.00, real=0.01 secs] 
    遍历次数为：16
    Heap
     PSYoungGen      total 2560K, used 134K [0x00000000ffd00000, 0x0000000100000000, 0x0000000100000000)
      eden space 2048K, 6% used [0x00000000ffd00000,0x00000000ffd219f0,0x00000000fff00000)
      from space 512K, 0% used [0x00000000fff80000,0x00000000fff80000,0x0000000100000000)
      to   space 512K, 0% used [0x00000000fff00000,0x00000000fff00000,0x00000000fff80000)
     ParOldGen       total 7168K, used 4846K [0x00000000ff600000, 0x00000000ffd00000, 0x00000000ffd00000)
      object space 7168K, 67% used [0x00000000ff600000,0x00000000ffabba00,0x00000000ffd00000)
     Metaspace       used 3498K, capacity 4496K, committed 4864K, reserved 1056768K
      class space    used 384K, capacity 388K, committed 512K, reserved 1048576K
    java.lang.OutOfMemoryError: Java heap space
    	at java.util.Arrays.copyOf(Arrays.java:3332)
    	at java.lang.AbstractStringBuilder.ensureCapacityInternal(AbstractStringBuilder.java:124)
    	at java.lang.AbstractStringBuilder.append(AbstractStringBuilder.java:448)
    	at java.lang.StringBuilder.append(StringBuilder.java:136)
    	at com.atguigu.java1.GCTest.main(GCTest.java:21)
    
    Process finished with exit code 0

*  \[`PSYoungGen`: 1319K->0K(2560K)\] ：`年轻代总空间为 2560K` ，`回收前内存占用 1319K ，经过垃圾回收后内存占用0K`
 *  \[`ParOldGen`: 6782K->4864K(7168K)\] ：`老年代总空间为 7168K` ，`回收前内存占用 6782K ，经过垃圾回收后内存占用4864K`
 *  8102K->4864K(9728K)：堆内存总空间为 9728K ，当前占用 8102K ，经过垃圾回收后内存占用 4864K
 *  \[`Metaspace`: 3452K->3452K(1056768K)\] ：元空间总空间为 1056768K ，当前占用 3452K ，经过垃圾回收后剩余 3452K
 *  0.0050464 secs ：垃圾回收用时 0.0050464 secs

[Full GC (Ergonomics) [PSYoungGen: 1319K->0K(2560K)] [ParOldGen: 6782K->4864K(7168K)] 8102K->4864K(9728K), [Metaspace: 3452K->3452K(1056768K)], 0.0050464 secs] [Times: user=0.00 sys=0.00, real=0.01 secs]

--------------------

## 6、堆空间分代思想 ##

> **为什么需要分代？**
> 
>  *  方便GC回收, 因为我们new的对象, 基本上都是存放在新生代的`伊甸园区`, 新生代的对象, 一般生命周期都很短. 此时将`堆`分为`年轻代`和`老年代`. 我们经常对`存放生命周期短的年轻代`进行GC即可!

1.  为什么要把Java堆分代？不分代就不能正常工作了吗？经研究，不同对象的生命周期不同。`70%-99%的对象是临时对象。`
    
     *  **新生代**：有`Eden`、两块大小相同的`survivor（又称为from/to，s0/s1）`构成。
     *  **老年代**：`存放新生代中经历多次GC仍然存活的对象。`
2.  其实不分代完全可以，
    
    **分代的唯一理由就是 : `优化GC性能`**
    
     *  如果没有分代，那所有的对象都在一块，就如同把一个学校的人都关在一个教室。GC的时候要找到哪些对象没用，这样就会对堆的所有区域进行扫描。
     *  而很多对象都是朝生夕死的，如果分代的话，把新创建的对象放到某一地方，当GC的时候先把这块存储“朝生夕死”对象的区域进行回收，这样就会腾出很大的空间出来。

![image-20200707101511025][]

![image-20200707101543871][]

--------------------

## 7、内存分配策略 ##

> **内存分配策略或对象提升（Promotion）规则**

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** ，也就是经过Minor GC后，所有的对象都存活，因为Survivor比较小，所以就需要将Survivor无法容纳的对象，存放到老年代中。

> **代码示例**

*  代码

/** * 测试：大对象直接进入老年代 * -Xms60m -Xmx60m -XX:NewRatio=2 -XX:SurvivorRatio=8 -XX:+PrintGCDetails * * @author shkstart shkstart@126.com * @create 2020 21:48 */
    public class YoungOldAreaTest { 
        public static void main(String[] args) { 
            byte[] buffer = new byte[1024 * 1024 * 20];//20m
    
        }
    }

*  JVM 参数

-Xms60m -Xmx60m -XX:NewRatio=2 -XX:SurvivorRatio=8 -XX:+PrintGCDetails
    设置堆空间的初始化和最大容量为60M, 年轻代和老年代的比例为1:2, 年轻代中的伊甸园区和两个幸存者区的比例为: 8:1:1, 并打印它们的日志信息

*  整个过程并没有进行垃圾回收，并且 ParOldGen 区直接占用了 20MB 的空间，说明大对象直接怼到了老年代中

Heap
     PSYoungGen      total 18432K, used 2637K [0x00000000fec00000, 0x0000000100000000, 0x0000000100000000)
      eden space 16384K, 16% used [0x00000000fec00000,0x00000000fee935c8,0x00000000ffc00000)
      from space 2048K, 0% used [0x00000000ffe00000,0x00000000ffe00000,0x0000000100000000)
      to   space 2048K, 0% used [0x00000000ffc00000,0x00000000ffc00000,0x00000000ffe00000)
     ParOldGen       total 40960K, used 20480K [0x00000000fc400000, 0x00000000fec00000, 0x00000000fec00000)
      object space 40960K, 50% used [0x00000000fc400000,0x00000000fd800010,0x00000000fec00000)
     Metaspace       used 3469K, capacity 4496K, committed 4864K, reserved 1056768K
      class space    used 381K, capacity 388K, committed 512K, reserved 1048576K
    
    Process finished with exit code 0

--------------------

## 8、为对象分配内存 ##

### 8.1、为什么有 `TLAB` ###

> **问题：堆空间都是共享的么？**
> 
>  *  不一定，因为还有`TLAB`这个概念，**在堆中划分出一块区域，为`每个线程所独占`**

> **为什么有TLAB（Thread Local Allocation Buffer）？**

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

### 8.2、什么是 TLAB ###

> **什么是 TLAB？**

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

![image-20200707103547712][]

### 8.3、TLAB 分配过程 ###

> **TLAB 的说明**

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

> **TLAB 分配过程**

![image-20200707104253530][]

> **代码示例**

*  代码

/** * 测试-XX:UseTLAB参数是否开启的情况:默认情况是开启的 * * @author shkstart shkstart@126.com * @create 2020 16:16 */
    public class TLABArgsTest { 
        public static void main(String[] args) { 
            System.out.println("我只是来打个酱油~");
            try { 
                Thread.sleep(1000000);
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
        }
    }

*  查看 UseTLAB 标志位的状态

C:\Users\Heygo>jps
    C:\Users\Heygo>jinfo -flag UseTLAB 15420

*  我并没有设置任何 JVM 参数，通过命令行查看 TLAB 是否开启：结论是`默认情况是开启 TLAB`  
    ![image-20200729094733850][]

--------------------

## 9、堆空间参数设置 (`重点`) ##

### 9.1、常用参数设置 ###

> **官方文档**
> 
>  *  [https://docs.oracle.com/javase/8/docs/technotes/tools/unix/java.html][https_docs.oracle.com_javase_8_docs_technotes_tools_unix_java.html]

> **常用参数设置**

1.  **-XX:+PrintFlagsInitial**：查看所有的参数的默认初始值
2.  **-XX:+PrintFlagsFinal**：查看所有的参数的最终值（可能会存在修改，不再是初始值）
3.  \-Xms：初始堆空间内存（默认为物理内存的1/64）
4.  **-Xmx**：最大堆空间内存（默认为物理内存的1/4）
5.  **-Xmn**：设置新生代的大小（初始值及最大值）
6.  **-XX:NewRatio**：配置新生代与老年代在堆结构的占比
7.  **-XX:SurvivorRatio**：设置新生代中Eden和S0/S1空间的比例
8.  **-XX:MaxTenuringThreshold**：设置新生代垃圾的最大年龄
9.  **-XX:+PrintGCDetails**：输出详细的GC处理日志
10. **-XX:+PrintGC** 或 -verbose:gc ：打印gc简要信息
11. **-XX:HandlePromotionFalilure**：是否设置空间分配担保, 当YoungGC后, 幸存者区仍然满了, 就将新对象直接存在老年代

### 9.2、空间分配担保 ###

> **关于空间分配担保**

**在发生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

> **代码示例**

*  代码

/** * 测试堆空间常用的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：是否设置空间分配担保 * * @author shkstart shkstart@126.com * @create 2020 17:18 */
    public class HeapArgsTest { 
        public static void main(String[] args) { 
    
        }
    }

--------------------

## 10、致命面试题 (`重点`) ##

> **堆是分配对象的唯一选择么？**
> 
>  *  栈上分配 : 在栈上分配对象; 前提是该对象不会发生逃逸. (`在一个方法里产生并销毁的对象, 该对象不会通过参数,返回值传递到方法外`)
>  *  标量替换
> 
> 但是通过`逃逸分析`的缺点, 而且我们主流的`Hotspot JVM` 明确说明不使用`逃逸分析`这项技术; 所以说: **堆上分配是对象的唯一选择!**

**在《深入理解Java虚拟机》中关于Java堆内存有这样一段描述：**

1.  随着`JIT编译期`的发展与`逃逸分析技术`逐渐成熟，**栈上分配、标量替换**优化技术将会导致一些微妙的变化，**所有的对象都分配到堆上也渐渐变得不那么“绝对”了。**
2.  在Java虚拟机中，对象是在Java堆中分配内存的，这是一个普遍的常识。但是，有一种特殊情况，那就是`如果经过逃逸分析（Escape Analysis）后`发现，一个对象并没有逃逸出方法的话，那么就可能被优化成栈上分配。**这样就无需在堆上分配内存，也无须进行垃圾回收了。这也是最常见的堆外存储技术。**
3.  此外，前面提到的基于OpenJDK深度定制的TaoBao VM，其中创新的GCIH（GC invisible heap）技术实现off-heap，将生命周期较长的Java对象从heap中移至heap外，并且GC不能管理GCIH内部的Java对象，以此达到降低GC的回收频率和提升GC的回收效率的目的。

**如何将在堆上分配对象内存 变为 在栈上分配，需要使用`逃逸分析`手段。**

1.  这是一种可以有效减少Java程序中同步负载和内存堆分配压力的跨函数全局数据流分析算法。
2.  `通过逃逸分析`，**Java Hotspot编译器能够分析出一个新的对象的引用的`使用范围`从而决定是否要将这个对象分配到堆上。**
3.  逃逸分析的基本行为就是`分析对象动态作用域`：
    
     *  **当一个对象在方法中被定义后，对`象只在方法内部使用`，则认为`没有发生逃逸`**。
     *  **当一个对象在方法中被定义后，`它被外部方法所引用`，则认为`发生逃逸`。例如作为调用参数传递到其他地方中。**

### 10.1、逃逸分析 ###

> **逃逸分析举例**

*  `没有发生逃逸的对象，则可以分配到栈上，随着方法执行的结束，栈空间就被移除`

public void my_method() { 
        V v = new V();
        // use v
        // ....
        v = null;
    }

*  下面代码中的 StringBuffer sb 发生了逃逸`(因为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的对象实体是否有可能在方法外被调用。 * @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.  **在JDK 1.7 版本之后，`HotSpot中默认就已经开启了逃逸分析`**
2.  如果使用的是较早的版本，开发人员则可以通过：
    
     *  选项`“-XX:+DoEscapeAnalysis"`显式开启逃逸分析
     *  通过选项`“-XX:+PrintEscapeAnalysis"`查看逃逸分析的筛选结果

> **逃逸分析结论**

*  **`开发中能使用局部变量的，就不要使用在方法外定义`**。(因为成员变量, 会导致多线程访问该变量, 造成该变量的线程不安全. 如果是局部变量, 首先局部变量存储在虚拟机栈中, 是线程私有的, 所以不会造成安全问题)

> **逃逸分析之代码优化**

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

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

### 10.2、栈上分配 ###

> **栈上分配**

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

**栈上分配举例**

*  代码

/** * 栈上分配测试 * -Xmx256m -Xms256m -XX:-DoEscapeAnalysis -XX:+PrintGCDetails * * @author shkstart shkstart@126.com * @create 2020 10:31 */
    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 { 
    
        }
    }

**未开启逃逸分析的情况 :**

*  JVM 参数设置

-Xmx256m -Xms256m -XX:-DoEscapeAnalysis -XX:+PrintGCDetails

*  日志打印：`发生了 GC ，耗时 46ms`

[GC (Allocation Failure) [PSYoungGen: 65536K->808K(76288K)] 65536K->816K(251392K), 0.0009467 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
    [GC (Allocation Failure) [PSYoungGen: 66344K->872K(76288K)] 66352K->880K(251392K), 0.0006768 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
    花费的时间为： 46 ms

*  堆上面有好多好多 User 对象  
    ![image-20200729102928375][]

**开启逃逸分析的情况 :**

*  JVM 参数设置

-Xmx256m -Xms256m -XX:+DoEscapeAnalysis -XX:+PrintGCDetails

*  日志打印：`并没有发生 GC ，耗时 3ms ，栈上分配是真的快`

花费的时间为： 3 ms

*  注意: 不是说`栈上分配`吗，为啥堆中还是有 User 对象？  
    ![image-20200729103126273][]

### 10.3、同步省略 (锁消除) ###

> **同步省略**

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

*  例如下面的智障代码，`根本起不到锁的作用`

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

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

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

**字节码分析**

*  代码

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

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

![image-20200729103650309][]

### 10.4、标量替换 ###

> **分离对象或标量替换**

1.  **标量（scalar）是指一个无法再分解成更小的数据的数据。Java中的`原始数据类型`就是`标量`**。
2.  相对的，那些`还可以分解的数据`叫做`聚合量（Aggregate）`，Java中的`对象`就是`聚合量`，因为他可以`分解成其他聚合量和标量`。
3.  在`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);
    }

**结论：**

1.  可以看到，`Point这个聚合量经过逃逸分析后，发现他并没有逃逸，就被替换成两个聚合量了`。
2.  那么标量替换有什么好处呢？就是可以大大`减少堆内存的占用`。**因为一旦不需要创建对象了，那么就不再需要分配堆内存了。**
3.  `标量替换为栈上分配提供了很好的基础。`

**标量替换参数设置**

*  参数 -XX:+ElimilnateAllocations：开启了标量替换（默认打开），允许`将对象打散分配在栈上`。

**代码示例**

*  代码

/** * 标量替换测试 * -Xmx100m -Xms100m -XX:+DoEscapeAnalysis -XX:+PrintGC -XX:-EliminateAllocations * * @author shkstart shkstart@126.com * @create 2020 12:01 */
    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");
        }
    }

**未开启标量替换**

*  JVM 参数

-Xmx100m -Xms100m -XX:+DoEscapeAnalysis -XX:+PrintGC -XX:-EliminateAllocations

*  日志分析：`伴随着 GC 的垃圾回收，用时 46ms`

[GC (Allocation Failure)  25600K->816K(98304K), 0.0009418 secs]
    [GC (Allocation Failure)  26416K->792K(98304K), 0.0007337 secs]
    [GC (Allocation Failure)  26392K->792K(98304K), 0.0006104 secs]
    [GC (Allocation Failure)  26392K->856K(98304K), 0.0009474 secs]
    [GC (Allocation Failure)  26456K->824K(98304K), 0.0007392 secs]
    [GC (Allocation Failure)  26424K->808K(101376K), 0.0009449 secs]
    [GC (Allocation Failure)  32552K->720K(101376K), 0.0010633 secs]
    [GC (Allocation Failure)  32464K->720K(100352K), 0.0004493 secs]
    花费的时间为： 46 ms
    
    Process finished with exit code 0

**开启标量替换**

*  JVM 参数

-Xmx100m -Xms100m -XX:+DoEscapeAnalysis -XX:+PrintGC -XX:+EliminateAllocations

*  日志分析：`无垃圾回收，用时 4ms`

花费的时间为： 4 ms
    
    Process finished with exit code 0

> **逃逸分析参数设置总结 :**

1.  上述代码在主函数中调用了`1亿次alloc()方法`，进行`对象`创建
2.  由于User对象实例需要占据约16字节的空间，因此累计分配空间达到将近1.5GB。
3.  如果堆空间小于这个值，就必然会发生GC。使用如下参数运行上述代码：

-server -Xmx100m -Xms100m -XX:+DoEscapeAnalysis -XX:+PrintGC -XX:+EliminateAllocations

这里设置参数如下：

1.  参数 -server：启动Server模式，因为在`server模式下，才可以启用逃逸分析。`
2.  参数 -XX:+DoEscapeAnalysis：启用逃逸分析
3.  参数 -Xmx10m：指定了堆空间最大为10MB
4.  参数 -XX:+PrintGC：将打印GC日志。
5.  参数 -XX:+EliminateAllocations：`开启了标量替换（默认打开`），允许将对象打散分配在栈上，比如对象拥有id和name两个字段，那么这两个字段将会被视为两个独立的局部变量进行分配

> **逃逸分析的不足**

1.  关于逃逸分析的论文在1999年就已经发表了，但直到JDK1.6才有实现，而且这项技术到如今也并不是十分成熟的。
2.  其**根本原因**就是`无法保证逃逸分析的性能消耗一定能高于他的消耗`。虽然经过`逃逸分析`可以`做标量替换、栈上分配、和锁消除`。但是逃逸分析自身也是需要进行一系列复杂的分析的，这其实也是一个相对耗时的过程。一个极端的例子，就是经过逃逸分析之后，发现没有一个对象是不逃逸的。那这个逃逸分析的过程就白白浪费掉了。
3.  虽然这项技术并不十分成熟，但是它也是即时编译器优化技术中一个十分重要的手段。注意到有一些观点，`认为通过逃逸分析，JVM会在栈上分配那些不会逃逸的对象，这在理论上是可行的，但是取决于JVM设计者的选择。`
4.  据我所知，**`Oracle Hotspot JVM中并未这么做`**，这一点在逃逸分析相关的文档里已经说明，所以`可以明确所有的对象实例都是创建在堆上`。
5.  目前很多书籍还是基于JDK7以前的版本，JDK已经发生了很大变化，**`intern字符串的缓存和静态变量曾经都被分配在永久代上，而永久代已经被元数据区取代`。但是`intern字符串缓存和静态变量并不是被转移到元数据区，而是直接在堆上分配`**，**所以这一点同样符合前面一点的结论：`对象实例都是分配在堆上`。**

> **堆是分配对象的唯一选择么？**
> 
>  *  综上：**`对象实例都是分配在堆上`**。

--------------------

## 11、堆小结 ##

1.  年轻代是对象的诞生、成长、消亡的区域，一个对象在这里产生、应用，最后被垃圾回收器收集、结束生命。
2.  老年代放置长生命周期的对象，通常都是从Survivor区域筛(年龄计数器为15的对象)选拷贝过来的Java对象。
3.  当然，也有特殊情况，我们知道**普通的对象可能会被分配在TLAB上**；
4.  如果对象较大，无法分配在 TLAB 上，则JVM会试图直接分配在Eden其他位置上
5.  如果对象太大，完全无法在新生代找到足够长的连续空闲空间，JVM就会直接分配到老年代
6.  **当GC只发生在年轻代中，回收年轻代对象的行为被称为Minor GC。**
7.  **当GC发生在老年代时则被称为Major GC或者Full GC。**
8.  一般的，Minor GC的发生频率`要比`Major GC高很多，即**老年代中垃圾回收发生的频率将大大低于年轻代**。 `(因为new的对象一般都分配在新生代, 新生代的对象都是朝生夕死的, 所以GC得频率很高)`

[image-20200706195127740]: /images/20221120/2f257096a91d4a30abee6d7fd17511ab.png
[image-20200706201904057]: /images/20221120/39e963b10f304db2a78a932014d0254e.png
[image-20200728203845527]: /images/20221120/57cc55d2214a4502b38e5c0662d81411.png
[image-20200728203928284]: /images/20221120/9e2ab6654ba2425bbf99916b4bdb080d.png
[image-20200728204013940]: /images/20221120/664a05be88034c18a4aeef4fc56fc393.png
[image-20200728204217567]: /images/20221120/82bbc43cbab649678c2a5d1a12bafd40.png
[image-20200728204241292]: /images/20221120/e83a5b927574468091e683d0f05c0e0e.png
[image-20200728210007805]: /images/20221120/49f5f695afc54155a704d2648f40a6e9.png
[image-20200706203419496]: /images/20221120/ce39f7336e5d481c917046326b614c89.png
[image-20200706203835403]: /images/20221120/88119a868f1f422f861865d6bbf2e09b.png
[image-20200728211208333]: /images/20221120/7103142f1cdc4b53b66da30b33d37fb8.png
[image-20200728211229103]: /images/20221120/36beab247640486db9d149c03c0b8c4c.png
[image-20200728211403370]: /images/20221120/287c1ce5ccfd4ac18dbf09bdfa64d701.png
[image-20200728213547918]: /images/20221120/2fd97bffc521457484c9efd6b9c86a30.png
[image-20200728214854972]: /images/20221120/cc913963df2749b9854a199a6f056220.png
[image-20200728224943553]: /images/20221120/5a91b918e27748e5bf3faa14cdcb826b.png
[image-20200728214905013]: /images/20221120/bf4a19a365f5481ab3032b2f8641fdab.png
[image-20200707075847954]: /images/20221120/3aabb5523d514bd7a0eb26b438374d8b.png
[image-20200707080154039]: /images/20221120/e98e4c14e6174c97989e8a88b9024c00.png
[image-20200707084208115]: /images/20221120/e30a95e344524c89b3257b1042160a58.png
[image-20200728221346507]: /images/20221120/ac19132283dd4600bfbc3469c8511417.png
[image-20200707084714886]: /images/20221120/a374988d0517492f8e1912f878354d7c.png
[image-20200707085232646]: /images/20221120/c2d6551d69844a118b034bba219c1580.png
[image-20200707085737207]: /images/20221120/d67e519a0c87493f863a9358e64456ac.png
[image-20200728225824888]: /images/20221120/80f8770682074e94b60140224bce10c2.png
[image-20200707091058346]: /images/20221120/1439491732784325be2148643f71b90c.png
[image-20200728230304833]: /images/20221120/a9f4491f50754fe881a8729289c5118b.png
[image-20200728230336191]: /images/20221120/b3a715c8b4ea4d489f7bfd7df5bdc758.png
[image-20200728230414510]: /images/20221120/0bf08883ab96443d862c70edeb074aa3.png
[image-20200728230542338]: /images/20221120/6ff0f0140cd34cee804bda9130b33d71.png
[image-20200707095606813]: /images/20221120/647280e2ac5a44c9b3440fee494b009f.png
[image-20200707101511025]: /images/20221120/a259d8b6ad02481a989a9b152257de0b.png
[image-20200707101543871]: /images/20221120/cfee477ba30c45c88ef0ce0347b8aab2.png
[image-20200707103547712]: /images/20221120/9a3c485450a8407da623fcd9052a2218.png
[image-20200707104253530]: /images/20221120/c9428f8adbd041c0a3d40dd721bf4e65.png
[image-20200729094733850]: /images/20221120/c24ab60670c94e4fb57399f9b29cbb87.png
[https_docs.oracle.com_javase_8_docs_technotes_tools_unix_java.html]: https://docs.oracle.com/javase/8/docs/technotes/tools/unix/java.html
[image-20200729102928375]: /images/20221120/98e8a631b2c748fab0da32376965c733.png
[image-20200729103126273]: /images/20221120/c23b7e57f07b48048057c85617b96b8e.png
[image-20200729103650309]: /images/20221120/881a9428c1704bfcb44b5c6435e92d3d.png