JVM入门到放弃.md · 安生/jvm

一、JVM 概述

## 1、什么是 JVM

**定义**

Java Virtual Machine -java程序的运行环境（Java 二进制字节码的运行环境）

**环境**

- 一次编写，到处运行
- 自动内存管理，垃圾回收功能
- 数组下标越界检查
- 多态

## 2、学习路线

![image-20211025235756465](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211025235804.png)

# 二、内存结构

## 1、程序计数器

### **1.1 定义**

Program Counter Register 程序计数器（寄存器）

- 作用，是记住下一条 jvm 指令的执行地址
- 特点
  - 是线程私有的
  - 不会存在内存溢出

### **1.2 作用**

![image-20211026000655499](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211026000656.png)

**指令执行流程：**拿到一条指令，交给 **解释器** ，解释器将其翻译成 **机器码** ，机器码才能交给 **CPU** 运行，与此同时会把 **下一条指令的执行地址** 存入 **程序计数器**，当指令执行完，**解释器**就会到 **程序计数器** **取出下一条指令**

**指令前面的数字**：代表 指令对应的内存地址，根据地址信息，就能找到指令，然后执行

**线程私有的：**当多个线程运行时，CPU 会有一个调度器给它们分配时间片，比如 ：线程1内的代码还没执行完，调度器就会把线程1的状态暂存，切换到线程2，当线程2时间片用完，再切换到线程1，再继续执行线程1的代码。若在线程上下文切换中，想要记住下一条指令执行到哪了，则还需用到 程序计数器，而程序计数器跟线程是私有的，它是属于线程1的，**每个线程都有自己的程序计数器**

## 2、虚拟机栈

### **2.1 定义**

Java Virtual Machine Stacks（Java 虚拟机栈）

- 每个线程运行时所需的内存，称为 虚拟机栈；
- 每个栈由多个栈帧（Frame）组成，对应着每次调用方法所占用的内存
  - 栈帧：参数、局部变量、返回地址
- 每个线程只能有一个活动栈帧，对应着当前**正在执行的那个方法**

### **2.2 问题思考**

1. 垃圾回收是否涉及栈内存？

答：因为栈内存无非就是一次次的方法调用所产生的栈帧内存，而栈帧内存在每一次方法调用结束后都会弹出栈，也就是会被自动回收，所以根本不需要垃圾回收管理栈内存

2. 栈内存的分配越大越好吗？

答：栈内存可以通过运行代码时，通过虚拟机参数来指定，相反，栈内存越大，线程数可能会变得更少，因为物理内存是一定的，若一个线程用了1M内存，总共的物理内存假设有500M，那理论上可以有500个线程能同时运行，倘若栈内存分配了2M，那同时只能运行250个线程，所以反而会影响线程数量。

![image-20211026004417646](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211026004419.png)

3. 方法内的局部变量是否线程安全？

答：若多个线程调用如下代码的方法，会不会造成 x 值混乱

因为 x 是方法内局部变量，一个线程对应一个栈，线程内每次方法的调用都会产生一个新的栈帧；

若为 static int x = 0;则会影响。

```java
   //局部变量线程安全问题
   class Demo{
   	// 多个线程同时执行该方法
   	static void add(){
   		int x = 0;
   		for(int i = 0;i < 5000;i++){
   			x++;
   		}
           System.out.println(x);
   	}
   }
   ```

![image-20211026005502308](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211026005503.png)

```java
	public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        sb.append(4);
        sb.append(5);
        sb.append(6);
        new Thread(() -> {
            m2(sb);
        }).start();
    }

public static void m1(){
        StringBuilder sb = new StringBuilder();
        sb.append(1);
        sb.append(2);
        sb.append(3);
        System.out.println(sb.toString());
    }
    public static void m2(StringBuilder sb){
        sb.append(1);
        sb.append(2);
        sb.append(3);
        System.out.println(sb.toString());
    }
    public static StringBuilder m3(){
        StringBuilder sb = new StringBuilder();
        sb.append(1);
        sb.append(2);
        sb.append(3);
        return sb;
    }
```

m1() ：不会有线程安全问题，sb 是方法内的局部变量，是线程私有的，其它线程不可能访问到

m2() ：有线程安全问题，sb作为方法的参数传递进来，那么就意味着有可能有其它线程能访问到它，它就不再是线程私有的了，即它是共享的。如main() 方法，主线程在修改 sb对象，新的线程也在修改。引用类型参数指向的对象地址都一样，所以其它线程对引用类型数据进行修改会影响原对象的值导致线程不安全。

m3()：有线程安全问题。虽然sb是局部变量，但把其当成一个返回结果返回了，返回了就意味着其它线程有可能拿到这个对象的引用，去并发的修改它

- 如果方法内局部变量没有逃离方法的作用访问，它是线程安全的
- 如果是局部变量引用了对象，并逃离了方法的作用方法，需要考虑线程安全

### **2.3 栈内存溢出**

- 栈帧过多导致栈内存溢出
- 栈帧过大导致栈内存溢出

```java
package com.alibaba.jvm;

/**
 * 栈内存溢出
 * -Xss256k
 */
public class Test2 {
    private static int count;
    public static void main(String[] args) {
        try {
            method1();
        }catch (Throwable throwable){
            throwable.printStackTrace();
            System.out.println(count);
        }
    }

public static void method1(){
        count++;
        method1();
    }

}
```

运行结果

![image-20211026115440633](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211026115448.png)

```java
package com.alibaba.jvm;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;

import java.util.Arrays;
import java.util.List;

/**
 * 栈内存溢出
 * -Xss256k
 */
public class Test3 {
    public static void main(String[] args) throws JsonProcessingException {
        Dept dept = new Dept();
        dept.setName("Market");

Emp emp1 = new Emp();
        emp1.setName("zhangsan");
        emp1.setDept(dept);
        Emp emp2 = new Emp();
        emp2.setName("lisi");
        emp2.setDept(dept);

dept.setEmps(Arrays.asList(emp1,emp2));

ObjectMapper mapper = new ObjectMapper();
        System.out.println(mapper.writeValueAsString(dept));
        /**
         {
            name:"Market",
            emps:[
                    {name:"zhangsan",dept:"name:"",emps:"" ..........."}
         ]
         }

}
}

class Emp{
    private String name;
    private Dept dept;

public String getName() {
        return name;
    }

public void setName(String name) {
        this.name = name;
    }

public Dept getDept() {
        return dept;
    }

public void setDept(Dept dept) {
        this.dept = dept;
    }
}
class Dept{
    private String name;
    private List<Emp> emps;

public String getName() {
        return name;
    }

public void setName(String name) {
        this.name = name;
    }

public List<Emp> getEmps() {
        return emps;
    }

public void setEmps(List<Emp> emps) {
        this.emps = emps;
    }
}
```

运行结果

![image-20211026120811299](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211026120812.png)

解决：

```java
class Emp{
    private String name;
    @JsonIgnore
    private Dept dept;
```

输出

![image-20211026120953739](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211026120954.png)

## 3、本地方法栈

![image-20211026123026935](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211026123028.png)

## 4、堆

### **4.1 定义**

Oracle官方定义

```
Java 虚拟机有一个在所有 Java 虚拟机线程之间共享的堆。堆是运行时数据区，从中分配所有类实例和数组的内存。

堆是在虚拟机启动时创建的。对象的堆存储由自动存储管理系统（称为垃圾回收器）回收；对象永远不会被显式释放。Java 虚拟机不假设任何特定类型的自动存储管理系统，存储管理技术可以根据实现者的系统需求来选择。堆可以是固定大小的，也可以根据计算的需要进行扩展，如果不需要更大的堆，则可以收缩。堆的内存不需要是连续的。

Java 虚拟机实现可以为程序员或用户提供对堆初始大小的控制，以及如果堆可以动态扩展或收缩，则可以控制最大和最小堆大小。

以下异常情况与堆相关联：

如果计算需要的堆多于自动存储管理系统所能提供的堆，Java 虚拟机将抛出一个 OutOfMemoryError.
```

Heap 堆

- 通过 new 关键字，创建的对象都会使用堆内存

特点

- 它是线程共享的，堆中对象都需要考虑线程安全问题
- 有垃圾回收机制

### **4.2 堆内存溢出**

```java
package com.alibaba.jvm;

import java.util.ArrayList;
import java.util.List;

/**
 * 堆内存溢出:java.lang.OutOfMemoryError: Java heap space
 * -Xmx8m
 */
public class Test4 {
    private static int count;
    public static void main(String[] args) {
        try {
            String str = "hello";
            List<String > list = new ArrayList<String>();
            while (true){
                str += str;
                list.add(str);
                count++;
            }
        }catch (Throwable throwable){
            throwable.printStackTrace();
            System.out.println(count);
        }
    }
}
```

运行结果

![image-20211026133715390](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211026133716.png)

问题分析：

```
list 的生存周期是什么？
从 try{
...
}即从被创建开始，到 catch()块前面，它都是一个有效范围，所以它不能被垃圾回收掉，也就是说，只要程序还没到 catch() ，它都一直有效，而里面的字符串对象一直被追加到list里面，所以这些字符串也相当于一直有人在使用它们，所以它们也不能被垃圾回收，所以随着字符串越来越多，它就会把堆空间占满
```

### **4.3 堆内存诊断**

1. jps 工具

- 查看当前系统有哪些 java 进程

2. jmap 工具

- 查看堆内存占用情况 jmap -heap 进程id

3. jconsole 工具

- 图形化界面，多功能检测工具，可以连续检测

```java
   @Slf4j
   public class Test6 {
       public static void main(String[] args) throws InterruptedException {
           log.debug("1....");
           Thread.sleep(20000);
           byte[] arr = new byte[1024 * 1024 * 10];//10MB
           log.debug("2.....");
           Thread.sleep(20000);
           arr = null;
           System.gc();
           log.debug("3......");
           Thread.sleep(2000000);
       }
   }
   ```

![image-20211026135225172](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211026135226.png)

### **4.4 案例-垃圾回收后，内存占用仍很高**

```java
package com.alibaba.jvm;

import lombok.extern.slf4j.Slf4j;

import java.util.ArrayList;
import java.util.List;

/**
 * 堆内存溢出:java.lang.OutOfMemoryError: Java heap space
 * -Xmx8m
 */
@Slf4j
public class Test7 {
    public static void main(String[] args) throws InterruptedException {
        List<Student> students = new ArrayList<>();
        for (int i = 0;i < 200 ;i++){
            students.add(new Student());
        }
        Thread.sleep(100000000);
    }
}
class Student{
    private byte[] bytes = new byte[1024 * 1024];
}

```

1. 执行以上代码，使用 `jps` 查看所有 java 进程数，16444为我这段代码对应的进程ID

![image-20211026140923454](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211026140924.png)

2. 使用 jmap -heap 16444 查看堆内存使用情况，可以看出，内存使用很高，19+185

![image-20211026141035855](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211026141036.png)

![image-20211026141047383](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211026141048.png)

3. 使用 jconsole 执行 GC 操作，再次使用 jmap -heap 16444 查看堆内存使用情况，可以看出内存的确减少一点，但久内存仍然很高，甚至更高

![image-20211026140530697](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211026140532.png)

![image-20211026141240948](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211026141241.png)

![image-20211026141251050](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211026141252.png)

4. 使用更高级的命令：jvisualvm，连接后执行 堆 Dump 操作

![image-20211026141456678](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211026141458.png)

再次单击【查找】按钮

![image-20211026141557038](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211026141558.png)

可以发现，占用内存最高的为ArrayList集合

![image-20211026141624388](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211026141625.png)

点进去观察，发现每一个占用达到1M多，且足足有200个

![image-20211026141751211](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211026141752.png)

![](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211026141752.png)

## 5、方法区

### **5.1 概念**

以下是Oracle官方的对方法区的定义

```
https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-2.html#jvms-2.5.4
Java 虚拟机有一个在所有 Java 虚拟机线程之间共享的方法区。方法区类似于传统语言的编译代码存储区，或类似于操作系统进程中的“文本”段。它存储每个类的结构，例如运行时常量池、字段和方法数据，以及方法和构造函数的代码，包括在类和接口初始化以及实例初始化（第2.9 节）中使用的特殊方法。

方法区是在虚拟机启动时创建的。尽管方法区在逻辑上是堆的一部分，但简单的实现可能会选择不进行垃圾收集或压缩它。本规范不强制要求方法区的位置或用于管理编译代码的策略。方法区可以是固定大小，也可以根据计算的需要进行扩展，如果不需要较大的方法区，可以缩小。方法区的内存不需要是连续的。

Java 虚拟机实现可以为程序员或用户提供对方法区初始大小的控制，以及在可变大小方法区的情况下，对最大和最小方法区大小的控制。

以下异常条件与方法区相关联：

如果方法区中的内存不能用于满足分配请求，Java 虚拟机将抛出一个OutOfMemoryError.
```

**元空间溢出演示**

```java
package com.alibaba.jvm;

import jdk.internal.org.objectweb.asm.ClassWriter;
import jdk.internal.org.objectweb.asm.Opcodes;

/**
 * 演示元空间溢出  Exception in thread "main" java.lang.OutOfMemoryError: Metaspace
 * -XX:MaxMetaspaceSize=8m
 */
public class Test8 extends ClassLoader{
    public static void main(String[] args) {
        int j = 0;
        try {
            Test8 test8 = new Test8();
            for (int i = 0; i < 10000; i++, j++) {
                // ClassWriter：生成类的二进制字节码
                ClassWriter classWriter = new ClassWriter(0);
                //版本号，public，类名，包名，父类，接口
                classWriter.visit(Opcodes.V1_8,Opcodes.ACC_PUBLIC,"Class" + i,null,"java/lang/Object",null);
                // 返回 byte[]
                byte[] code = classWriter.toByteArray();
                //执行类加载
                test8.defineClass("Class" + i,code,0,code.length);//Class 对象
            }
        }finally {
            System.out.println(j);
        }

}
}
```

运行结果

![image-20211026215955700](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211026220004.png)

### **5.2 组成**

1. JDK 1.6

![image-20211026222556982](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211026222558.png)

2. JDK 1.8以后

![image-20211026222624324](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211026222625.png)

Method Area（方法区）只是一个概念，一套规范。在 jdk1.6  PermGen（永久代）作为方法区的实现，而在 jdk1.8 以后，实现它的方式叫做 Metaspace（元空间）

**为什么要用元空间取代永久代？**

- 字符串存在永久代中，容易出现性能问题和内存溢出
- 类及方法的信息等比较难确定大小，因此对于永久代的大小指定比较苦难，太小容易出现永久代溢出，太大则容易导致老年代溢出
- 永久代会为GC带来不必要的复杂度，并且回收率低

### **5.3 运行时常量池**

先看代码

```java
public class Test9{
    public static void main(String[] args) {
        System.out.println("hello world");
    }
}
```

分析

```java
/**
 * 类要运行，首先要编译成二进制字节码
 * 字节码又由（类的基本信息、类的常量池、类方法的定义（包含虚拟机指令）
 */
```

1. 进入 .class 文件所在目录，输入命令 `javap -v Test9.class`

类的基本信息

![image-20211026230931103](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211026230932.png)

类的常量池

![image-20211026230953164](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211026230954.png)

类的方法定义，虚拟机指令

![image-20211026231029789](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211026231030.png)

- 常量池，就是一张表，虚拟机指令根据这张常量表找到要执行的类名、方法名、参数类型、字面量等信息
- 运行时常量池，常量池是 `*.class` 文件中的，当该类被加载，它的常量池信息就会放入运行时常量池，并把里面的符号地址变为真实地址

### **5.4 面试题解析**

```java
public class Test10 {
    public static void main(String[] args) {
        String s1 = "a";
        String s2 = "b";
        String s3 = "ab";
    }
}
```

为了搞清楚答案，我们需要从 字节码 和 常量池 的角度来分析底层原理

编译成字节码后，通过反编译查看常量池到底长什么样 ``javap -v Test10.class``

1. 找到 `main()` 方法，查看字节码![image-20211026235345811](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211026235346.png)

`0：ldc            #2` ：意思就是要到常量池中去2号位置加载一个信息，这个信息有可能是一个常量、对象的引用等等，而我们现在这个例子对应的是一个 字符串对象

`2: astore_1` ：作用是把 加载好的"a" 这个字符串对象存入 1号 的局部变量表中

同理 #3  #4

![image-20211026235905027](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211026235906.png)

2. 分析完上面的指令后，我们还要知道 常量池 和 串池 之间的关系。常量池是存在于我们的字节码文件，当它运行的时候，它就会被加载到运行时常量池，也就是 `Constant Pool ` 的指令信息会被加载到运行时常量池中，但加载完后，这些信息还仅仅是运行时常量池中的符号，还没有变为 Java 中的字符串对象，那什么时候才会变为 Java 中的字符串对象？得等到具体执行到引用它的那一行代码上，如下

```json
   		 0: ldc           #2                  // String a
            2: astore_1
            3: ldc           #3                  // String b
            5: astore_2
            6: ldc           #4                  // String ab
            8: astore_3
   ```

比如执行到 ` 0: ldc           #2                  // String a`

lac  #2  会把  a  符号变为  “a”  字符串对象，之后会准备一块  `StringTable`  的空间，之后会把 “a”  作为  key 到   `StringTable`  去找一个取值相同的 key，没有的话，就会把 "a" 放入 串池  `StringTable`   中，同理 "b","ab" 一样。  `StringTable`  原理上是一个  `hashtable` 结构，不能扩容

3. ```java
   		   String s1 = "a";
           String s2 = "b";
           String s3 = "ab";
           String s4 = s1 + s2;
   ```

一样进行反编译

![image-20211027001825493](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211027001826.png)

```
    		 0: ldc           #2                  // String a
            2: astore_1
            3: ldc           #3                  // String b
            5: astore_2
            6: ldc           #4                  // String ab
            8: astore_3
            9: new           #5                  // class java/lang/StringBuilder
           12: dup
           13: invokespecial #6                  // Method java/lang/StringBuilder."<init>":()V
           16: aload_1
           17: invokevirtual #7                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
           20: aload_2
           21: invokevirtual #7                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
           24: invokevirtual #8                  // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
           27: astore        4
   
   ```

解析：

1、`9: new   #5    // class java/lang/StringBuilder`

new 创建对象，创建了一个 StringBuilder 对象

`new`

2、`13: invokespecial #6  // Method java/lang/StringBuilder."<init>":()V`

调用 StringBuilder 的 init 方法，其实就是StringBuilder构造方法

`new StringBuilder() `

3、`16: aload_1`

把 s1 加载进来，即调用方法前要把参数准备好，与 `2: astore_1` 是相对的，`2: astore_1` 是把其存入局部变量表中1号位置，`16: aload_1` 是从局部变量表中1号位置拿到数据

4、`invokevirtual #7 		// Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;`

调用 StringBuilder 的 append 方法，把`16: aload_1` 拿到的数据当作参数

`new StringBuilder().append(s1) `

5、同理 `20: aload_2`

`new StringBuilder().append(s1).append(s2) `

6、`24: invokevirtual #8       // Method java/lang/StringBuilder.toString:()Ljava/lang/String;`

`new StringBuilder().append(s1).append(s2).toString() `

7、`27: astore        4`

把 toString() 转换后的结果存入局部变量表

![image-20211027003015638](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211027003016.png)

8、看一下 StringBuilder 的 toString 方法，作用：将 StringBuilder 当前拼接好的值，又重新创建了新的字符串对象，然后存入 s4 对象

![image-20211027003240844](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211027003243.png)

9、继续看代码

```java
   public class Test10 {
       public static void main(String[] args) {
           String s1 = "a";
           String s2 = "b";
           String s3 = "ab";
           String s4 = s1 + s2;
           System.out.println(s3 == s4);
       }
   }
   false
   ```

当前串池  `StringTable` 里面的数据有：`a、b、ab` ,而 s4 引用的是 新的字符串对象，虽然值相同，但是 s3 是在串池中的，而 s4 是 new 出来的字符串对象，是在堆里面的，即存储位置不一样

再继续看代码,javac 编译期优化

```java
package com.alibaba.jvm;

/**
 * 类要运行，首先要编译成二进制字节码
 * 字节码又由（类的基本信息、类的常量池、类方法的定义（包含虚拟机指令）
 */
public class Test10 {
    public static void main(String[] args) {
        String s1 = "a";
        String s2 = "b";
        String s3 = "ab";
        String s4 = s1 + s2;
        String s5 = "a" + "b";
		System.out.println(s3 == s5);
    }
}
true
```

看最后的虚拟机指令/字节码 即可

![image-20211027004231567](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211027004232.png)

```
        27: astore        4
        29: ldc           #4                  // String ab
```

1、`27: astore        4`

到常量池中去找一个编号为4的符号，找到了 ab  这个符号，注意，它不是先找 a 再 找 b，而是直接找到已经拼接好的 ab 这个符号，并且存入 局部变量表，这是 “ab” 再串池 `Stringtable` 中已存在，所以不会创建新的字符串对象

**5.5 延迟字符串延迟加载**

```java
//演示字符串字面量也是【延迟】称为对象的，延迟加载
```

![image-20211027163640317](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211027163649.png)

观察String对象个数初始为2397，执行到 "0" 时，字符串对象为 2406 个，如果再走下去，从 1-0 这10个字符串对象已存在串池，所以继续执行，字符串个数不变，还是 2406

![image-20211027163842695](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211027163843.png)

### 5.5 StringTable特性之 intern

**StringTable特性**

- 常量池中的字符串仅是符号，第一次用到时才变为对象；
- 利用串池的机制，来避免重复创建字符串对象；
- 字符串变量拼接的原理是：StringBuilder
- 字符串常量拼接的原理是：编译期优化
- 可以使用 intern 方法，主动将串池中还没有的字符串对象放入串池
  - jdk1.8 将这个字符串对象尝试放入串池，如果有则并不会放入，如果没有则放入串池，会把串池中的对象返回；
  - jdk1.6 将这个字符串对象尝试放入串池，如果有则并不会放入，如果没有则会把此对象复制一份放入串池，会把串池中的对象返回；

看以下代码

```java
public class Test11 {
    public static void main(String[] args) {
        // 串池 ["a","b","ab"]
        // 堆中：new String("a") new String("b") new String("ab")
        String s = new String("a") + new String("b");

// 将字符串对象尝试放入串池中，如果串池中有这个字符串对象，则不会放入，且会把串池中的对象返回
        // 如果串池中没有这个字符串对象，则放入，且会把 串池中的对象返回
        String s2 = s.intern();
		// 若把 String s2 = s.intern(); 注释，则 s=="ab" 为 false
        System.out.println( s2 == "ab" );//true
        System.out.println( s == "ab" );//true

}
}
```

解析：

1、运行至 `String s = new String("a") + new String("b");`时

会在 串池中存入以下对象 ：串池 ["a","b","ab"]

堆中：new String("a") new String("b") new String("ab")

2、作出以下修改

```java
1        String x = "ab";
2        String s = new String("a") + new String("b");

3        // 将字符串对象尝试放入串池中，如果串池中有这个字符串对象，则不会放入
4        // 如果串池中没有这个字符串对象，则放入，且会把串池中的对象返回
5        String s2 = s.intern();
6        System.out.println( s2 == x );//true
7        System.out.println( s == x );//false
```

运行到 `String x = "ab"`，在串池中创建了 ["ab"]

运行到 `String s = new String("a") + new String("b")` 在串池中创建了 ["ab"，"a","b"]

堆中创建 new String("a") new String("b") new String("ab"),注意此时 堆中的 “ab" 并非 串池中的 "ab"

### 5.5 面试题

接下来看以下几道题

```java
public class Test12 {
    public static void main(String[] args) {
       String s1 = "a";
       String s2 = "b";
       String s3 = "a" + "b";//编译期被入串池
       String s4 = s1 + s2;//两个变量的拼接 运行期
       String s5 = "ab";
       String s6 = s4.intern();
	// s4 没能入池成功，但返回常量池中的对象 
        System.out.println( s3 == s4 );//false
        System.out.println( s3 == s5 );//true
        System.out.println( s3 == s6 );//true

String x2 = new String("c") + new String("d");
        String x1 = "cd";
        x2.intern();

System.out.println(x1 == x2);//false

//  s4.intern()与String s6 = s4.intern()不一样
        
    }
}
```

若调换以下位置

```java
		String x2 = new String("c") + new String("d");
		x2.intern();
        String x1 = "cd";
        
        System.out.println(x1 == x2);//true
```

`x2.intern()` ,x2先入池，相当于 堆中的 "ab" 对象已入池

### 5.6 StringTable位置

1. 在 jdk 1.6 中，StringTable 是常量池中的一部分，随常量池存储在 永久代 中，内存回收效率很低，只有在 Pool GC 时才会触发垃圾回收

![image-20211027182603268](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211027182605.png)

2. 在 jdk 1.8 中，把 StringTable 转移到 堆 中，因为 永久代 的内存回收效率很低，

![image-20211027182717970](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211027182718.png)

接下来看以下代码

```java
package com.alibaba.jvm;

import java.util.ArrayList;
import java.util.List;

/**
 * 演示 StringTable 位置
 * 在 jdk8 下设置 -Xmx10m   设置堆的最大内存
 *               -XX:-UseGCOverheadLimit
 * 在 jdk6 下设置 -XX:MaxPermSize=10m // 把永久代内存设置小些
 */
public class Test13 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        int i = 0;
        try {
            for (int j = 0; j < 260000; j++) {
                list.add(String.valueOf(j).intern());//为了不被垃圾回收 存入list
                i++;
            }
        }catch (Throwable throwable){
            throwable.printStackTrace();
        }finally {
            System.out.println(i);
        }

}
}

```

1、不做任何设置，运行该代码，可以发现并没有问题

![image-20211027184011005](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211027184012.png)

2、设置 堆的最大内存 `-Xmx10m` 运行，发现 jdk1.8 用到的堆空间

![image-20211027184110844](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211027184111.png)

![image-20211027184139978](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211027184141.png)

### 5.6 StringTable 垃圾回收

上代码

```java
package com.alibaba.jvm;

import java.util.ArrayList;
import java.util.List;

/**
 * 演示 StringTable 垃圾回收
 * -Xmx10m 虚拟机堆内存最大值
 * -XX:+PrintStringTableStatistics 打印字符串表的统计信息 通过它可以清楚看到串池中字符串实例的个数，包括占用的大小信息
 * -XX:+PrintGCDetails -verbose:gc 打印垃圾回收的详细信息，包括花费的时间
 * -Xmx10m -XX:+PrintStringTableStatistics -XX:+PrintGCDetails -verbose:gc
 */
public class Test14 {
    public static void main(String[] args) {
        int i = 0;
        try {

}catch (Throwable throwable){
            throwable.printStackTrace();
        }finally {
            System.out.println(i);
        }

}
}

```

```java
/**
 * 演示 StringTable 垃圾回收
 * -Xmx10m 虚拟机堆内存最大值
 * -XX:+PrintStringTableStatistics 打印字符串表的统计信息 通过它可以清楚看到串池中字符串实例的个数，包括占用的大小信息
 * -XX:+PrintGCDetails -verbose:gc 打印垃圾回收的详细信息，包括花费的时间
 * -Xmx10m -XX:+PrintStringTableStatistics -XX:+PrintGCDetails -verbose:gc
 */
```

![image-20211027212956405](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211027212957.png)

**解读**

StringTable 底层实现类似于 hashTable ，数组＋链表结构

每个数组长度，称为 “桶”，“桶”的个数称为：buckets 对应上图，默认个数：60013

存储字符串对象的个数 entries：1776 即键值对个数

串池中字符串对象的个数 literals：1776

占用空间：footprint：0.6M左右

即现在什么也没做，但里面已经有 1000 多个字符串对象了（类名、方法名等等）

现做如下改动

```java
public class Test14 {
    public static void main(String[] args) {
        int i = 0;
        try {
            for (int j = 0; j < 100; j++) {
                String.valueOf(j).intern();
                i++;
            }
        }catch (Throwable throwable){
            throwable.printStackTrace();
        }finally {
            System.out.println(i);
        }

}
}
```

![image-20211027213658013](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211027213659.png)

解读：

可以看出，多了100个字符串对象

再做修改

```java
for (int j = 0; j < 50000; j++) {
	...
}
```

![image-20211027213952343](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211027213953.png)

![image-20211027214004021](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211027214005.png)

因为我们前面 `-Xmx10m 虚拟机堆内存最大值` 给其分配了10M的堆内存，50000对于堆内存来说很大，内存一紧张，就会触发垃圾回收机制。

### 5.7 StringTable 性能调优

**解读**

前面我们了解到 StringTable 底层是一个 哈希表，而哈希表的性能与其大小息息相关，如果哈希表的“桶”个数较多，那么元素相对就会比较分散，那么哈希碰撞的几率就会减少，那么查找的速度就会变快，反之。

`-Xms500m -Xms500m -XX:+PrintStringTableStatistics -XX:StringTableSize=1100`

**上案例**

```java
package com.alibaba.jvm;

import java.io.*;
import java.util.ArrayList;
import java.util.List;

/**
 * -XX:StringTableSize=200000 -XX:+PrintStringTableStatistics
 */
public class Test14 {
    public static void main(String[] args) throws IOException{
        int i = 0;
        try (BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream("E:\\IDEA\\workspace\\aliabab-TheardConcurrent\\src\\main\\java\\com\\alibaba\\jvm\\linux.words"),"utf-8"))) {
            String line = null;
            long start = System.nanoTime();
            while (true){
                line = reader.readLine();
                if (line == null){
                    break;
                }
                line.intern();
            }
            System.out.println("cost:"+ (System.nanoTime() - start) / 1000000);
            }

}
}

```

![image-20211101142357313](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211101142358.png)

**结果分析**

花费了 0.3s ，结果还是很快的

`Number of buckets       :     60013`：桶个数，6w个，也就是说，linux.word这个文件的40多w个单词，分散在一个 6w 的桶里。即平均每个桶链表长度也就是7个单词左右，默认是 6w个

修改桶的个数为：20w，重新运行

![image-20211101141955337](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211101141956.png)

![image-20211101142144634](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211101142146.png)

将桶的个数调到：1100，再次运行，可以发现，明显变慢了，为什么呢？

因为每往 StringTable 放一个字符串，它就要在哈希表中查找，看看有没有这个字符串，如果有，那就不能放进去，因为要保证 StringTable 的字符串对象唯一性；

**结论：**

如果系统里，字符串常量较多，可以适当调整 StringTable 桶的个数，调整大些，这样能有更好的哈希分布，减少哈希冲突

![image-20211101142055068](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211101142056.png)

### 5.8 StringTable 性能调优 下

**方法**

- 调整  `-XX:StringTableSize=桶个数`
- 考虑将字符串对象是否入池

**上代码**

```java
public static void main(String[] args) throws IOException{
        List<String> list = new ArrayList<>();
        System.in.read();
        int i = 0;
        for (int j = 0; j < 10; j++) {
            try (BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream("E:\\IDEA\\workspace\\aliabab-TheardConcurrent\\src\\main\\java\\com\\alibaba\\jvm\\linux.words"),"utf-8"))) {
                String line = null;
                long start = System.nanoTime();
                while (true){
                    line = reader.readLine();
                    if (line == null){
                        break;
                    }
                    list.add(line);
                }
                System.out.println("cost:"+ (System.nanoTime() - start) / 1000000);
            }
        }
    System.in.read();
    }
```

运行后打开：`jvisualvm` ,还没引入前，内存占用情况

![image-20211101142425918](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211101142427.png)

读取文件后，再次查看内存占用情况，可以发现内存占用变高了

![image-20211101142445412](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211101142446.png)

修改代码,入池操作，可以发现，入池后，内存减少100M左右

```java
list.add(line.intern());
```

![image-20211101142504458](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211101142505.png)

## 6、直接内存

### 6.1 定义

Direct Memory

- 常见于 NIO 操作时，用于数据缓冲区
- 分配回收成本较高
- 不受 JVM 内存回收管理
- 并不属于 Java 虚拟机的内存管理，而是属于系统内存

### **6.2 文件读写过程**

1. CPU 
   - Java 本身不具备磁盘读写能力，若想要调用磁盘读写，必须调用操作系统提供的函数，CPU会从“用户态”切换到”内核态“
2. 内存
   - 当切换到 “内核态”，可由CPU 的函数读写磁盘文件的内容，比如从磁盘文件读取出来，读取后，会在操作系统内存划出一块“系统缓冲区”，磁盘文件会先分次存储到系统缓冲区，而系统缓冲区的代码，Java不能直接运行系统缓冲区的代码，所以 Java 会在 堆内存 中去分配一块 Java缓冲区 对应代码中 new byte[]
   - Java缓冲区到达下一个状态（用户态）再去调用输出流的 写入 操作，反复进行读写
   - 因为涉及到两块缓冲区，所以效率不是很高

![image-20211101142528062](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211101142529.png)

再看一下 directBuffer

![image-20211101142551050](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211101142552.png)

看代码

```java
package com.alibaba.jvm;

import java.io.*;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.util.ArrayList;
import java.util.List;

/**
 * 演示 ByteBuffer 作用
 */
public class Test15 {
    static final String FROM = "D:\\百度网盘资料\\H马Java面试专题课2021\\day04-框架篇_[itjc8.com]\\day04-框架篇\\57-循环依赖_set循环依赖_debug_getSingleton.mp4";
    static final String TO = "D:\\百度网盘资料\\JUC高并发编程2021最新版\\30-JUC高并发编程-读写锁-案例实现.mp4";
    static final int _1MB = 1024 * 1024;
    public static void main(String[] args) throws IOException{
        io();
        directBuffer();
    }
    private static void directBuffer(){
        long start = System.nanoTime();
        try (FileChannel from = new FileInputStream(FROM).getChannel();
             FileChannel to = new FileOutputStream(TO).getChannel()
        ) {
            ByteBuffer buffer = ByteBuffer.allocateDirect(_1MB);
            while (true){
                int len = from.read(buffer);
                if (len == -1){
                    break;
                }
                buffer.flip();
                to.write(buffer);
                buffer.clear();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        long end = System.nanoTime();
        System.out.println("directBuffer 用时：" + (end - start) / 1000_000.0 );
    }

private static void io(){
        long start = System.nanoTime();
        try (FileInputStream from = new FileInputStream(FROM);
             FileOutputStream to = new FileOutputStream(TO)
        ){
            byte[] buf = new byte[_1MB];
            while (true){
                int len = from.read(buf);
                if (len == -1){
                    break;
                }
                to.write(buf,0,len);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        long end = System.nanoTime();
        System.out.println("io 用时：" + (end - start) / 100_000.0);
    }

}

```

运行结果

![image-20211101142611668](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211101142612.png)

### 6.3 直接内存溢出

```java
package com.alibaba.jvm;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.util.ArrayList;
import java.util.List;

/**
 * 演示直接内存溢出
 */
public class Test16 {

static final int _100MB = 1024 * 1024 * 100;
    public static void main(String[] args) throws IOException{
        List<ByteBuffer> list = new ArrayList<>();
        int i = 0;
        try {
            while (true){
                ByteBuffer buffer = ByteBuffer.allocateDirect(_100MB);//每次分配 100M 内存
                list.add(buffer);
                i++;
            }
        }finally {
            System.out.println(i);
        }
    }

}

```

运行结果

![image-20211101142635364](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211101142636.png)

# 三、垃圾回收

## 1、如何判断对象可以回收

**1.1 可达性分析算法**

首先要确定一系列根对象，何为根对象？可以理解为 **肯定不能被当成垃圾回收的对象**。 在垃圾回收之前，我们首先会对堆内存中的对象进行扫描，判断每一个对象是不是被 根对象 直接或间接的引用，如果是，那么这个对象就不能被垃圾回收，反之。

- Java 虚拟机中的垃圾回收机器采用可达性分析来探索所有存活的对象
- 扫描堆中的对象，看是否能够沿着 GC Root 对象 为起点的引用链找到该对象，如果能找到，表示这个对象需要保留，若找不到，表示可以回收
- 哪些对象可以作为 GC Root ？
  - 通过 Memory Analyzer （ MAT ）工具，可以形象的看到哪些 GC Root 对象
  - 下载地址：https://www.eclipse.org/downloads/download.php?file=/mat/1.8/rcp/MemoryAnalyzer-1.8.0.20180604-win32.win32.x86_64.zip&mirror_id=1290

**看代码**

```java
/**
 * 演示 GC Roots
 */
public class Test1 {

public static void main(String[] args) throws IOException {
        List<Object> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        System.out.println(1);
        System.in.read();

list = null;
        System.out.println(2);
        System.in.read();
        System.out.println("end.....");
    }

}
```

验证的功能：验证 list 对象，有值 和 无值 的情况下做一个对比，看看哪些对象能够称为 根对象

运行代码，使用 jmap 查看 堆内存占用情况，而 MAT 需要配合 jmap 一同使用，通过 jmap 把内存快兆抓取出来，接下来才能用 MAT 工具进行分析

![image-20211101142657957](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211101142659.png)

```shell
jmap -dump:format=b,live,file=1.bin 12052
```

```
//分析
jmap -dump：  表明不是查看堆内存的占用情况，而是要把堆内存当前运行时的状态 转储成一个文件
//具体用法
format = b：	 表示转储文件的格式，b 表示文件格式是二进制
live：表示只抓取存活的对象，已经被垃圾回收掉的，直接过滤掉，而且加上 live 之前，在抓取快兆之前，就会进行一次垃圾回收，因为只有进行垃圾回收以后，才能知道哪些是存活对象，即主动触发垃圾回收
file：存为什么文件名
```

1. list 置空之前，存储一个快兆名为：a.bin

列出了当前内存占用最多的那些对象的饼状图，

![image-20211101143045367](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211101143046.png)

通过这个选线，可查看我们当前我们抓取的快兆里，GC Root 都有哪些

![image-20211101142721070](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211101142722.png)

通过下表，可以看到哪些对象是根对象，且其把根对象分为4大类

第一类：System Class ：系统类，由启动类加载类加载的类，且肯定不会被垃圾回收

第二类：Native Stack：Java虚拟机在执行时，偶尔需调用操作系统的方法，本地方法栈

第三类：Thread：活动线程。正在运行的线程，能把活动线程中所使用的对象当成垃圾回收吗？显然不行，线程正在运行，这时我们把它正在使用的对象当成垃圾回收了，那就没法继续运行了

每次方法调用都会产生一个栈帧，即栈帧内所使用的对象，可以作为根对象

下图显示的是，主线程栈帧内用到的一些变量情况

注意，要把引用变量和对象分开，就好比下面代码，list 只是一个引用，它存在于活动栈帧中，它是一个局部变量，而 ` new ArrayList<>()` 是存储在 堆 里的

看下图的 ArrayList ，那么它是不是由我们上面代码 list 的引用所引用？它就是一个根对象，在活动线程执行过程中，局部变量所引用的对象，是可以作为根对象的

包括方法参数 String[] args，所引用的字符串数组对象，也是根对象

```
List<Object> list = new ArrayList<>();
```

![image-20211101142738911](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211101142740.png)

第四类：Busy Monitor：正在加锁的对象，比如同步锁机制，synchronized 关键字，被 synchronized  加锁的对象不能当成垃圾回收，如果被回收，将来谁来解锁？

![image-20211028203648204](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211028203649.png)

2.list 置空之前，存储一个快兆名为：b.bin

从下图可以发现，没有 ArrayList 那个对象了，为什么没有了呢？

代码 `list = null` ，局部变量已经 置为 null 了，也就是它不再引用 ArrayList 对象，而我们执行了 `live` 所以进行垃圾回收，垃圾回收就会把不再有人引用它的ArrayList对象给回收掉，所以在根对象列表中就找不到它了

![image-20211028210136697](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211028210137.png)

## 1.2 Java 中的四种引用

![image-20211029123632192](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211029123640.png)

上图中，所有实线都表示强引用，虚线表示：软、弱、虚、终结器引用。

其实像我们平时用的所有引用，都属于强引用，比如 创建了一个对象，把这个对象通过 “ = ” 赋值给了一个变量，那么这个对象就 强引用 了这个对象。

1. 强引用：只要沿着 GC Root 的引用链能够找到它，那么它就不会被垃圾回收。比如上图，沿着 C对象（GC Root) 能找到 A1对象，那么 A1对象 就不能被垃圾回收。只有 GC Root 对象对 A1对象 的引用都断开时，才会被垃圾回收。

2. 软引用：还是参照上图，只要 A2对象 没有被直接的 强引用 所引用（上图 A2对象被 B对象 直接引用，不能被回收），那么当发生垃圾回收时，它就有可能被垃圾回收。比如上图中， A2对象 被 C对象（GC Root）间接引用。那么 A2对象 什么时候才能被垃圾回收呢？当发生垃圾回收时，并且内存不够时，就发生垃圾回收，但垃圾回收一次后，发现内存仍不够，这时就会把 软引用 所引用的对象释放掉，它认为 软引用 所引用的对象不够重要。

3. 弱引用：只要发生垃圾回收，不管内存够不够，都会把 弱引用 引用的对象回收

软、弱引用还可以配合 **引用队列** 一起工作，什么意思呢？就是当 软、弱引用 的对象被回收掉后，那么 软、弱引用 其实本身也是一个对象，那如果再创建它们时为其分配了 **引用队列** ，那么 当 软、弱引用 的对象被回收掉后，它们就会进入一个 **引用队列** 。

那么问题来了，为什么要做这么一个处理呢？因为，不管是 软、弱引用 ，它们自身也要占用一定的内存空间，那么如果想对它们占用的内存空间进行 释放，那么就需要用到 **引用队列** 来找到它们。比如它们可能还被强引用 所引用，那么就可以在 **引用队列** 中遍历它们，然后释放

![image-20211029130623782](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211029130625.png)

4. 虚引用：与 软、弱引用不同，虚引用 必须配合 引用队列 使用，也就是创建 虚引用 对象时，它就会关联一个 引用队列。在创建 ByteBuffer 实现对象时，它就会创造一个 Cleaner 的虚引用对象，ByteBuffer 会分配一块 直接内存，并且会把 直接内存 地址传给 虚引用对象，那么为何要做这个操作？将来如果 ByteBuffer 没有强引用所引用它了，那么 ByteBuffer 就可能被垃圾回收，但它被垃圾回收了，它所分配的 直接内存 并不能被 Java 的垃圾回收机制管理，那怎么解决？当 ByteBuffer 被垃圾回收时，让 虚引用 对象进入 **引用队列** ，而 虚引用 所在的 **引用队列** 会由一个叫 `Reference Handler` 的线程定时去 引用队列 找，看看有无一个 新入队 的 `Cleaner` ，如果有，那么它就会调用 `Cleaner` 对象的 `clean()` 方法， `clean()` 方法就会根据 直接内存地址调用 `Unsafe.freeMemory()` 方法，把直接内存释放掉，这样就不会由 直接内存 导致的内存泄漏。

![image-20211029132924936](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211029132926.png)

5. 终结器引用：与 软、弱引用不同，终结器引用 必须配合 引用队列 使用，也就是创建 虚引用 对象时，它就会关联一个 引用队列。我们都知道，所有的 Java 对象，都会继承一个 Object 父类，而 Object 父类都有一个 `finalize()` 终结方法，当对象 重写了 终结方法，并且没有被 强引用 所引用，那么它就可以被垃圾回收，那么问题来了，这个 `finalize()` 终结方法 什么时候会被调用？其实，你重写了 `finalize()` 终结方法，你就希望这个终结方法将来在这个对象垃圾回收时被调用吧？其实它就是靠这个 终结器引用来达到目的的。如上图，当 A4 对象被垃圾回收时，终结器引用就会被加入 **引用队列** ，但注意，此时 A4对象 还没被垃圾回收，即不是立刻回收，而是先将 终结器引用 放入 引用队列，再由一个 **优先级很低**的线程去查看 引用队列 中是否有 终结器引用，如果有，就会根据这个 终结器引用 找到 要作为垃圾回收的对象 ，并且调用  `finalize()`方法，等**下一次垃圾回收**时，就能把这个对象占用的内存垃圾回收掉。效率低

![image-20211029134315686](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211029134316.png)

## 1.3 软引用-引用场景

看代码

```java
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

/**
 * 演示 软引用 的应用场景
 * -Xmx20m -XX:+PrintGCDetails -verbose:gc
 *  -Xmx20m  设置堆内存大小
 *	-XX:+PrintGCDetails -verbose:gc  打印垃圾回收信息
 */
public class Test2 {
    private static final int _4MB = 4 * 1024 * 1024;
    public static void main(String[] args) throws IOException {
        List<byte[]> list = new ArrayList<>();
        for (int i = 0; i < 5; i++) {
            list.add(new byte[_4MB]);//往 list 集合添加 byte[] 数组，4M内存
        }
        System.in.read();
    }
}
```

我们已经提前设置堆内存大小为 20M `-Xmx20m`，但该该方法中，循环 5 次，每次往 list 集合添加一个 byte[] 数组，大小为 20M，这时肯定会发生错误，并且是 堆内存空间不足，如下

![image-20211029141541628](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211029141542.png)

其实像我们在开发中，这样的场景很多，比如 `list.add(new byte[_4MB])`，这里的 `new byte[_4MB]` 可能是读取网络上的一系列图片，而这些图片需要方法放到 list 集合中，但这些 “图片” 资源并不属于我们的核心业务资源，但由于这些 “图片” 资源数量过多过大，此时如果我们使用 **强引用** 来引用这些资源，就可能引起上图的 **内存溢出** 错误，那么像这些 非核心业务资源 ，我们能否在内存紧张时，将其释放掉呢？以后我再需要用到时，再读取一遍不就行了？所以这种场景，并不适合 **强引用** ，而此时，**软引用** 就恰到好处。

**使用软引用**

```java
public static void soft(){
        // list 并非直接引用 byte[] 数组
        // list 先引用 SoftReference ，SoftReference 再引用 byte[] 数组
    	// List 与 SoftReference 之间是强引用
        List<SoftReference<byte[]>> list = new ArrayList<>();
        for (int i = 0; i < 5; i++) {
            //构造软引用对象，内部再包装 软引用 所真正引用的 对象
            SoftReference<byte[]> reference = new SoftReference<>(new byte[_4MB]);
            System.out.println(reference.get());//获得内部包装的 byte[] 数组
            list.add(reference);
            System.out.println(list.size());
        }
        System.out.println("循环结束：" + list.size());
        for (SoftReference<byte[]> ref : list) {
            System.out.println(ref.get());
        }
}
```

**再次运行**

![image-20211029143103987](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211029143104.png)

**结果分析：**程序能正常运行，且在第一次循环中，都能获得 SoftReference 内部包装的 byte[] 数组。但在循环结束后，再次遍历 list 集合，发现只有 最后一个元素 不为 null，这是为什么呢？我们深入了解一下执行过程，为了看清楚过程，我们把 垃圾回收的详细信息 打印出来，配置 `-XX:+PrintGCDetails -verbose:gc`

**再次运行**

![image-20211029143822601](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211029143824.png)

结果分析：前3次循环都没什么问题，但在 第4次 循环时，内存就很紧张了，触发了一次 垃圾回收。

1、第一次垃圾回收 Minor GC

![image-20211029144402871](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211029144404.png)

`GC (Allocation Failure) ` 内存分配失败触发的垃圾回收。

`[PSYoungGen: 2301K->488K(6144K)]` 把新生代的内存从 2301K 回收到 488K，可以看出效率还是很高的。

2、第二次垃圾回收

![image-20211029144904311](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211029144905.png)

但是可以看到，回收效率不高，所以再次触发 垃圾回收

3、第三次垃圾回收 Full GC

![image-20211029145008763](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211029145010.png)

由于 第2次 垃圾回收，效率不高，再次触发一次更全面的垃圾回收 Full GC，不光是要回收 新生代，还要回收 老年代，新生代 回收后，没回收多少，老年代也是。在经历一次 完全的垃圾回收后，内存仍不够，因为前4次 已经将内存占满，这时就触发了 软引用 的垃圾回收。

软引用 垃圾回收的特性就是：一次完全垃圾回收后，内存空间仍然不足，就会把 软引用 所引用的对象释放掉，所以又触发了一次 新的垃圾回收

4、第四次垃圾回收 软引用 垃圾回收

![image-20211029145638651](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211029145639.png)

新生代内存已变成0，老年代的内存也释放很多，代价就是把前面占用的内存都释放掉，只有最后一个 byte[] 数组被存放

5、堆内存信息解析

![image-20211029145847698](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211029145848.png)

程序运行结束后，老年代只占用 7% 的内存，新生代只占用 77% 的内存

**小结：**空间紧张时，软引用的好处

## 1.4 软引用---引用队列

演示完上面的代码，我们发现，在内部不足时，就会把 软引用 所引用的对象释放掉，但是最后，遍历 list 集合时，有点 软引用 对象为 null，对于这些软引用对象，其实没必要保留在 list 集合中，因为有效的只有最后一个，其它为 null 的，保留了也没意义，且占用内存，所以遇到这种情况，我们需要对 软引用 本身也做一个清理。那问题来了，怎么清理这些无用的软引用？

看代码，配合 引用队列  进行处理： `ReferenceQueue`

```java
 public static void soft(){
        // list 并非直接引用 byte[] 数组
        // list 先引用 SoftReference ，SoftReference 再引用 byte[] 数组
        List<SoftReference<byte[]>> list = new ArrayList<>();// List 与 SoftReference 之间是强引用

// 引用队列
        // 是个泛型，类型跟 软引用 的泛型一致
        ReferenceQueue<byte[]> queue = new ReferenceQueue<>();

for (int i = 0; i < 5; i++) {
            // 构造软引用对象，内部再包装 软引用 所真正引用的 对象
            // 关联了软引用对象 和 引用队列。
            // 当软引用所引用的对象 被 回收时，那么软引用自身就会被加入 引用队列中
            SoftReference<byte[]> reference = new SoftReference<>(new byte[_4MB],queue);
            System.out.println(reference.get());
            list.add(reference);
            System.out.println(list.size());
        }
        // 先去 引用队列 中查找，看看哪些 软引用 已经被加入到 引用队列 中
        // queue.poll() 从队列中获取最先放入队列的元素
        // 从队列中获取无用的 软引用 对象，并移除
        Reference<? extends byte[]> poll = queue.poll();
        while (poll != null){
            list.remove(poll);
            poll = queue.poll();//再到队列中获取下一个软引用对象
        }

System.out.println("引用队列移除结束：" + list.size());
        for (SoftReference<byte[]> ref : list) {
            System.out.println(ref.get());
        }
}
```

运行结果

![image-20211029155353668](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211029155402.png)

## 1.5 弱引用 -- 应用场景

看代码

```java
 public static void weak(){
        //  list --->  WeakReference ---> byte[]
        List<WeakReference<byte[]>> list = new ArrayList<>();
        for (int i = 0; i < 5; i++) {
            WeakReference<byte[]> reference = new WeakReference<>(new byte[_4MB]);
            list.add(reference);
            for (WeakReference<byte[]> ref : list) {
                System.out.print(ref.get() + "  ");
            }
            System.out.println();
        }
        System.out.println("循环结束：" + list.size());
  }
```

运行结果

![image-20211029160235203](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211029160237.png)

**结果分析**

1、第一次垃圾回收

第一次垃圾回收时，内存仍足够

2、第二次垃圾回收

循环到 第5个 时，再想通过 WeakReference 放到 list 中时，内存不够了，这时又触发一次垃圾回收，这时候 上一个（第四个）被垃圾回收了，回收成 null 了，这时 第5个 才能放进去

**修改代码**

```java
for (int i = 0; i < 6; i++)
```

运行结果

![image-20211029160651578](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211029160652.png)

**结果分析**

循环到 第5个 时，再想通过 WeakReference 放到 list 中时，内存不够了，这时触发一次垃圾回收，这时候 上一个（第四个）被垃圾回收了，回收成 null 了，这时 第5个 才能放进去。循环到 第6个 时，再想通过 WeakReference 放到 list 中时，内存不够了，这时触发一次垃圾回收，这时候 上一个（第五个）被垃圾回收了，回收成 null 了，这时 第6个 才能放进去

**修改代码**

```java
for (int i = 0; i < 10; i++) 
```

运行结果

![image-20211029161003415](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211029161004.png)

**结果分析**

循环到 第9个 时，把 第8个 当成垃圾回收了，相当于内存中只存放了 4个byte[] 数组对象

循环到 第10个 时，新的问题发现了，由于 弱引用 本身也占有一定的内存，所以放 第10个 时，放不下了，此时触发了一次 `Full GC` ， `Full GC` 触发后，前面 9 个弱引用 所引用的 byte[] 数组都被清空，之前 前3个 仍留着，但  `Full GC`  触发，都被置空了

**使用 ReferenceQueue 获取无用的 弱引用 对象，并移除 **

```java
public static void weak(){
        //  list --->  WeakReference ---> byte[]
        List<WeakReference<byte[]>> list = new ArrayList<>();
        ReferenceQueue queue = new ReferenceQueue();
        for (int i = 0; i < 10; i++) {
            WeakReference<byte[]> reference = new WeakReference<>(new byte[_4MB],queue);
            list.add(reference);
            for (WeakReference<byte[]> ref : list) {
                System.out.print(ref.get() + "  ");
            }
            System.out.println();
        }
        Reference poll = queue.poll();
        while (poll != null){
            list.remove(poll);
            poll = queue.poll();
        }
        System.out.println("使用 ReferenceQueue 获取无用的 弱引用 对象，并移除");
        for (WeakReference<byte[]> ref : list) {
            System.out.println(ref);
        }

System.out.println("循环结束：" + list.size());
}
```

运行结果

![image-20211029162022827](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211029162023.png)

## 1.7 四种引用总结

1. **强引用**
   - 只有所有 GC Root 对象都不通过【强引用】引用该对象，该对象才能被垃圾回收
2. **软引用（SoftRefence）**
   - 仅有软引用引用该对象时，在垃圾回收后，内存仍不足时会再次触发垃圾回收，回收软引用对象
   - 可以配合引用队列来释放软引用自身
3. **弱引用（WeakReference）**
   - 仅有弱引用引用该对象时，在垃圾回收时，无论内存是否充足，都会回收弱引用对象
   - 可配合引用队列来释放弱引用自身
4. **虚引用（PhantomReference）**
   - 必须配合引用队列使用，主要配合 ByteBuffer 使用，被引用对象回收时，会将虚引用入列，由 Reference Handler 线程调用虚引用相关方法释放直接内存
5. **终结器引用（FinalReference）**
   - 无需手动编码，但其内部配合引用队列使用，在垃圾回收时，终结器引用入队（被引用对象暂时没有被回收），再由 Finalizer 线程通过终结器引用找到被引用对象并调用它的 finalizer 方法，第二次 GC 时才能回收被引用对象

## 1.6 垃圾回收算法

**定义：**之前我们了解了一个对象是否可以作为垃圾被回收，即沿着 GC Root 对象的引用链去找，扫描整个堆对象的过程中，如果发现该对象被直接引用了，那么就不能回收，反之。但是具体的垃圾回收，其实也依赖于一些 垃圾回收算法，常见的有：标记清除、标记整理、复制。这三种算法

### 1、标记清除

具体步骤：

1. 先标记，看看哪些对象可以是垃圾，把没有被引用的对象标记出来

![image-20211029170043415](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211029170044.png)

2. 清除垃圾，把被标记的内存空间释放

![image-20211029170219844](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211029170220.png)

**注意：**这里可能会产生一个误区，释放，是不是意味着要把内存的每个字节进行 清0 操作呢？

其实并不会，只需要把这个被清除的对象的 起始、结束地址 记录下来，放在空闲的地址列表里就可以，下次再分配新对象时，就到这个空闲的地址列表里去找，看看有没有一块足够的空间容纳新对象，并不会把占用的内存做 清0 操作。

**优点：**速度快，只需把垃圾对象内存的起始、结束地址做记录就可以，无需额外处理

**缺点：**产生内存碎片， 即清除后不会再对内存空间进行整理操作，所以当我们再次分配一个较大的对象时，比如 数组，而 数组 的分配需要一段连续的内存空间，但是清除后的每一个内存空间都不够 数组 存放，而其实总的 内存空间 却可以容纳我的数组对象，但由于清理后的内存空间不连续，所以造成新对象仍不能有一个有效的内存给新的数组对象用，所以会造成**内存溢出**问题

![image-20211029171229556](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211029171230.png)

### 2、标记整理

具体步骤：

1. 先标记，看看哪些对象可以是垃圾，把没有被引用的对象标记出来

![image-20211029171431321](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211029171432.png)

2. 为了避免 “标记清除” 算法产生内存碎片。在清理垃圾的过程中，会把可用的对象向前移动，让内存更为紧凑，整理之后，我们发现，内存空间更为紧凑了，这样就不会造成 “标记清除” 算法产生内存碎片

![image-20211029171755131](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211029171756.png)

**优点：**没有内存碎片

**缺点：**由于清理的过程涉及到 对象的移动，那么效率自然就变低。比如我们有一些局部变量，而这些局部变量引用了这个移动的对象，所以自然需要改变 引用的引用地址，涉及到内存区块的拷贝移动，还要把所有引用的地址改变，所以效率滴，速度慢

### 3、复制算法

定义：把内存区划成大小相等的两个区，即下图的 `FROM` 和 `TO` ，其中， `TO` 这个内存区始终空闲，里面一个对象都没有

![image-20211029172714416](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211029172715.png)

步骤：

1. 先标记，看看哪些对象可以是垃圾，把没有被引用的对象标记出来

![image-20211029172909617](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211029172911.png)

2. 然后从 `FROM` 区，把存活的对象（没被垃圾回收的对象）转移到 `TO` 内存区，复制的过程中，会完成碎片的整理，即不会产生内存碎片，复制完，清空 `FROM` 内存区的垃圾

![image-20211029173128073](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211029173129.png)

3. 交换  `FROM` 和 `TO` 的位置，原来的 `TO` 变成 `FROM` ， 原来的 `FROM`变成 `TO`，即 `TO` 总是空闲的区域

**优点：**不会产生内存碎片

**缺点：**会占用双倍的内存空间

## 1.7 分代垃圾回收

### **1、定义**

前面我们学习了三种垃圾回收算法，但实际上 JVM 虚拟机不会单独采用某一种算法，而是结合三种算法协同工作，具体的实现称为：分代垃圾回收。

![image-20211029230529404](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211029230537.png)

把整个堆内存分为两块：新生代、老年代。而新生代又分为3个部分，即：伊甸园、幸存区 From、幸存区 To。

那么问题来了，为什么要做区域划分呢？主要是因为 Java 中有的对象需要长期使用，长时间使用的对象，就把其放到 **老年代** 中，而那些用完了就可以回收掉的对象，就可以放在 **新生代** 中，这样就可以根据对象的生命周期不同，进行不同的垃圾回收策略，老年代的垃圾回收机制，就很久触发一次，而新生代垃圾回收触发的几率就多一点，这样针对不同的区域我们采用不同的算法就可以对垃圾回收有一个更好的管理

### 2、分代垃圾回收机制工作原理

1. 当我们创建一个新的对象时，那么这个对象默认就会使用 **伊甸园** 这块空间，接下来可能会有很多对象被创建，所以也会分配到 **伊甸园** 中。而随着对象创建，内存逐渐增加，当内存不够时，若再想往 **伊甸园** 中添加对象，这时就会触发一次 垃圾回收。

![image-20211029230914194](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211029230915.png)

2. 新生代的垃圾回收一般称为：`Minor GC` ，而 `Minor GC`  触发后，就会采用 **可达性分析算法** 沿着 `GC Root` 引用链去 **伊甸园** 中查找，看这些对象有用或者可以被当成垃圾回收，即先 标记，标记完成后，就会采用 **复制** 算法，把存活的对象复制到 **幸存区To** ，而 复制到幸存区To的对象，寿命就会加1，而至于 **伊甸园** 中的对象，就可以全部被当成垃圾回收。

![image-20211029231708432](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211029231709.png)

3. 但我们知道，完成一次 **复制** 算法后，`From` 和 `To` 的位置就会互换，但内存空间不会变，即只是交换位置。这就是第一次垃圾回收产生的效果

![image-20211029231920204](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211029231921.png)

4. 完成第一次垃圾回收后，此时 **伊甸园** 内存空间足够了，又可以往里面添加对象了

![image-20211029232119499](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211029232120.png)

5. 又过了一段时间，此时 **伊甸园** 的内存空间又满了，又需进行 **第二次垃圾回收** ，第二次垃圾回收，除了要把 伊甸园 存活的对象找到以外，还需在 **幸存区To** 中判断有无需要继续存活的对象，即 **幸存区To** 中的对象也有可能在第二次垃圾回收中被回收，与第一次垃圾回收类似，把存活的对象复制到 **幸存区To** ，而 复制到幸存区To的对象，寿命就会加1，而至于 **伊甸园** 中的对象，就可以全部被当成垃圾回收。且完成一次 **复制** 算法后`From` 和 `To` 的位置需要互换

![image-20211029232715784](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211029232716.png)

6. 但 幸存区 中的对象不会一直存在，当超过一定寿命时（默认 15 ），就会把该对象存到 **老年代**

![image-20211029232924867](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211029232926.png)

7. 但当 **老年代** 与 **新生代** 内存空间同时不足时，这时就会触发一次 `Full GC` ，进行 **老年代** 的垃圾回收，此时就会完成一整轮垃圾回收，从新生代到老年代

![image-20211029233202038](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211029233203.png)

**注意：** 其实，当发生 `Minor GC` 时，就会发生一次：stop the world。什么意思呢？其实就是在发生垃圾回收时，必须暂停其它用户线程，由垃圾回收线程完成垃圾回收，当把对象从 **伊甸园、幸存区From** 拷贝到 **幸存区To** 时，即等垃圾回收的动作做完后，其它的用户线程才能继续运行。

那么问题来了，为什么需要把其它用户线程都暂停呢？这是因为在垃圾回收的过程中，涉及到对象的复制，也就是对象地址会发生改变，而这种情况下，如果多个用户线程都在运行，就会造成混乱，即对象都在移动，其它的线程再根据原来的地址访问这个对象，就访问不到了。

### 3、相关 VM 参数

![image-20211030140912686](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211030140922.png)

### 4、案例演示垃圾回收过程

1. 实例一

```java
   /**
    * 通过案例演示整个垃圾回收过程
    */
   public class Test3 {
       public static void main(String[] args) {
   
       }
   }
   ```

设置虚拟机参数

```shell
   -Xms20M -Xmx20M -Xmn10M -XX:+UseSerialGC -XX:+PrintGCDetails -verbose:gc
   ```

参数解读

```java
   // -Xms20M -Xmx20M -Xmn10M -XX:+UseSerialGC -XX:+PrintGCDetails -verbose:gc
   
       /** 虚拟机参数
        *  -Xms20M  堆初始大小为 20M
        *  -Xmx20M 堆最大为 20M
        *  -Xmn10M 新生代为 10M
        *  -XX:+UseSerialGC   一种垃圾回收器，JDK1.8 默认不是该垃圾回收器 特点是幸存区比例不会动态调整 有助于现象演示
        *  -XX:+PrintGCDetails -verbose:gc 打印 GC 详情
        */
   ```

运行结果

![image-20211030145740028](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211030145741.png)

运行结果解读

由于没有创建任何对象，所以内存空间足够，也就没有打印任何 GC 信息

- `def new generation` 新生代，参考上图，为何我们明明划了 10M 内存给新生代，而实际上只有 9M 多呢？按照 80% 原则，伊甸园占了 80%，也就是8M，而 幸存区From 和 幸存区To 各占 1M，但是幸存区To 的 1M 是不能用的
     - `eden space` 一开始占了 28%？这时因为 Java 程序运行时都会加载一些类，创建一些对象，而这些对象一开始用的就是伊甸园内存

- `tenured generation` 老年代或晋升年代

- `Metaspace ` 元空间

2. 实例二

```java
    public static void main(String[] args) {
           ArrayList<byte[]> list = new ArrayList<>();
           list.add(new byte[_7MB]);
    }
   ```

根据上图，我们知道 伊甸园大小有 8M多，而有 28% 内存被占用，所有再想放一个 7M 的 byte[] 数组肯定放不下了，所以这时就会触发一次垃圾回收，运行代码

![image-20211030151147611](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211030151148.png)

结果解析

```
   新生代
   DefNew: 2333K->718K(9216K), 0.0028276 secs
   DefNew：代表在新生代
   2333K：回收前的内存占用
   718K：回收后的内存占用
   9216K：新生代的总大小
   0.0028276 secs：垃圾回收耗时
   
   堆
   2333K->718K(19456K), 0.0038767 secs
   2333K：堆回收前的内存占用
   718K：回收后的内存占用
   19456K：堆的总大小
   ```

```
     进行一次垃圾回收后 新生代的占用内存情况
   def new generation   total 9216K, used 8132K
     eden space 8192K,  90% used 
     from space 1024K,  70% used 
     to   space 1024K,   0% used 
     
     eden space 8192K,90% used ：90%占用，可以了解到刚刚那个 byte[] 数组已被存入伊甸园
     一些对象被放入 To 中，然后 From 和 To 位置交换 所以看到 From 占用70%
     
   ```

3. 实例三

```java
   public static void main(String[] args) {
           ArrayList<byte[]> list = new ArrayList<>();
           list.add(new byte[_7MB]);
           list.add(new byte[_1MB]);
   }
   ```

运行结果

![image-20211030152300172](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211030152301.png)

结果分析

存放一个 7M 的 byte[] 数组会触发一次 GC，再存放一个  1M 的 byte[] 数组 会再触发一次垃圾回收

```
   新生代
   DefNew: 8050K->0K(9216K), 0.0093825 secs
   DefNew：代表在新生代
   8050K：回收前的内存占用
   0K：回收后的内存占用
   9216K：新生代的总大小
   0.0093825 secs：垃圾回收耗时
   
   堆
   8050K->7849K(19456K), 0.0094259 secs
   8050K：堆回收前的内存占用
   7849K：回收后的内存占用，效果不显著，已经快占满了，可回收的对象很少
   19456K：堆的总大小
   ```

```
   def new generation 
   	eden space 8192K,  13% used 可以看到，回收后伊甸园占用已经很少了
   	from space 1024K,   0% used
   	to   space 1024K,   0% used
   
   
   tenured generation   total 10240K, used 7849K 
   	the space 10240K,  76% used	对象已经直接晋升到老年代了
   ```

4. 实例四 存储大对象

```java
    public static void main(String[] args) {
           ArrayList<byte[]> list = new ArrayList<>();
           list.add(new byte[_8MB]);
    }
   ```

其实 8M 已经超出 伊甸园 的总容量，包括 From 也放不下它，那怎么办呢？遇到这种情况，如果老年代空间足够，该大对象会直接晋升到老年代，且不会触发垃圾回收，看运行结果

![image-20211030153419962](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211030153421.png)

5. 实例五

```java
    public static void main(String[] args) {
           ArrayList<byte[]> list = new ArrayList<>();
           list.add(new byte[_8MB]);
           list.add(new byte[_8MB]);
    }
   ```

因为新生代的内存空间不足以容纳 8M 的 byte[] 数组，老年代也放不下两个8M 的byte[] 数组，且这两个 byte[] 数组都是由一个 GC Root 的 ArrayList对象引用，所以不能释放， 所以会造成内存溢出，当然内存溢出之前，还会进行一次自救

![image-20211030153839202](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211030153840.png)

6. 实例六，运行在线程里

```java
    public static void main(String[] args) throws InterruptedException {
           new Thread(()->{
               ArrayList<byte[]> list = new ArrayList<>();
               list.add(new byte[_8MB]);
               list.add(new byte[_8MB]);
           }).start();
           System.out.println("sleep.....");
           Thread.sleep(5000);
       }
   ```

思考，若将 实例五 的代码运行在一个线程里，会不会因为 内存溢出 导致主线程停止运行？

![image-20211030154602842](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211030154604.png)

即一个子线程的 内存溢出 并不会导致 整个主线程停止

## 1.8 垃圾回收器

### 1、类型

1. 串行
   - 单线程
   - 堆内存较小，适合个人电脑
2. 吞吐量优先
   - 多线程
   - 堆内存较大，多核 CPU
   - 让单位时间内，STW 的时间最短 ，如 0.2 + 0.2 = 0.4，垃圾回收时间占比最低，这样就称 吞吐量高
3. 响应时间优先
   - 多线程
   - 堆内存较大，多核 CPU
   - 尽可能让单次 STW 的时间最短，如 0.1 + 0.1 + 0.1 + 0.1 + 0.1

### 2、串行

1、需要配置以下信息

```shell
-XX:+UseSerialGC

-XX:+UseSerialGC = Serial + SerialOld
Serial：工作在 新生代，采用的回收算法是：复制
SerialOld：工作在 老年代，采用的回收算法是：标记整理
且 新生代和老年代的垃圾回收器是分别运行的
若 新生代的内存不足，会采用 Serial 完成垃圾回收
若 老年代的内存不足，会采用 Serial 完成 Minor GC，SerialOld 完成 Full GC
```

![image-20211030234852132](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211030234853.png)

那么具体它的回收过程是怎样的呢？如上图，假设我们现在有多核CPU，刚开始这些线程都在运行，运行一段时间后，发现堆内存不够了，触发了一次垃圾回收，这时要让这些线程在一个安全点停下来，那为什么要让这些线程停下来呢？因为可能在垃圾回收的过程中，部分对象的地址要发生改变，为了保证安全的使用这些对象地址，则需要所有的用户线程到达一个安全点停下来，这时完成垃圾回收就不会有其它线程干扰了，否则如果移动了对象，地址改变了，其它线程来访问这个对象，就可能找到错误的地址的对象，程序就会出问题。

而 `Serial + SerialOld` 都是单线程的垃圾回收器，所以只有一个垃圾回收线程在运行，当这个垃圾回收线程在运行时，其它的用户线程就会进入 阻塞 状态，等待垃圾回收线程的结束。完事后再继续运行

### 3、吞吐量优先

1、需要配置以下信息

```
-XX:+UseParallelGC ~ -XX:+UseParallelOldGC
在 jdk 1.8 默认开启上面两个开关
-XX:+UseParallelGC：新生代并发垃圾回收器，采用复制算法
-XX:+UseParallelOldGC：老年代并发垃圾回收器，采用标记整理算法

-XX:+UseAdaptiveSizePolicy 采用自适应的新生代大小调整策略
-XX:GCTimeRatio=ratio 与 MaxGCPauseMillis 冲突
-XX:MaxGCPauseMillis=ms 最大暂停毫秒数 默认200ms
-XX:ParallelGCThreads=n 控制垃圾回收线程数
```

2、工作流程

![image-20211031000451485](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211031000452.png)

1. 刚开始这些线程都在运行，运行一段时间后，发现堆内存不够了，触发了一次垃圾回收，这时要让这些线程在一个安全点停下来。与 **串行** 不同，垃圾回收器会开启多个垃圾回收线程一起回收，垃圾回收线程数默认与CPU核数相关，但因为同时开启多个垃圾回收线程，所以在回收时，CPU会瞬间飚到100%。
2. 但是 垃圾回收线程 数可以通过 `-XX:ParallelGCThreads=n` 来控制
3. `ParallelGC` 比较智能，可以根据设置的参数，调整堆的大小以达到期望目标
4. `-XX:GCTimeRatio=ratio` 调整垃圾回收时间与总时间占比 1/(1+ratio)
5. `-XX:MaxGCPauseMillis=ms`  最大暂停毫秒数 默认200ms。

### 4、响应时间优先

1. 相关参数

```shell
   -XX:+UseConcMarkSweepGC ~ -XX:+UseParNewGC ~ SerialOld
   UseConcMarkSweepGC：concurrent(并发)、Mark(标记)、Sweep(清除)，一款基于标记清除的并发回收器
   
   
   -XX:ParallelGCThreads=n ~ -XX:ConcGCThreads=thread
   -XX:CMSInitiatingOccupancyFraction=percent
   -XX:+CMSScavengeBeforeRemark 一个开关
   ```

2. 运行流程

首先多个 CPU 开始并行执行，老年代发生了内存不足，线程在安全点停下来，这时 `UseConcMarkSweepGC`垃圾回收器开始工作，执行 **初始标记** 动作，在这个  **初始标记** 动作时，仍需要 STW ，即其它用户线程进入 阻塞 ，暂停下来，但是   **初始标记** 很快，因为只完成标记根对象，完成该动作后，用户线程就可以运行了，与此同时，垃圾回收线程继续 **并发标记** ，把剩余的垃圾找出来，但这时与其它用户线程是 并发进行的，当完成 **并发标记** 后，还需再 **重新标记** ，这时又需要 STW ，为什么呢？因为 我们在 **并发标记** 的同时，用户线程也在工作，工作的时候，现有的对象的引用可能就会改变，所以 **并发标记** 结束后，仍需再进行 STW，完成后，再进行 **并发清理** 。

整个过程，只有  **初始标记** 和 **重新标记** 需要 STW，整个过程时间短，符合 响应时间优先

虽然这种垃圾回收器对CPU的占用没有 `UseParallelGC` 高，就拿下图的例子，4核的CPU，只用了1核去做垃圾回收，所以对 CPU 的占用并不高，但是，用户线程也在运行，本来用户工作线程可以满负荷工作的，即本来4核CPU都能使用上，但是其中1核被垃圾回收占用了，所以用户工作线程只能占用原来的 3/4 的CPU的数量，所以对整个应用程序的吞吐量有一定影响，

![image-20211031002151295](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211031002152.png)

3. 参数解读

- `UseConcMarkSweepGC` 一款基于标记清除的，工作在老年代并发回收器，与之配合的是 `UseParNewGC` ，是一款工作在 新生代的 基于 复制算法的垃圾回收器，**并发**，指我们在进行垃圾回收的同时，其它用户线程也能同时进行，即用户线程和垃圾回收器的并发执行，但其在某几个阶段也需要进行 STW 。且有的时候，`UseConcMarkSweepGC`  会发生并发失败的情况，这时会采取补救措施，让老年代的垃圾回收器，从`UseConcMarkSweepGC` 并发垃圾回收器退化到 `SerialOld`  单线程垃圾回收器。
   - `ParallelGCThreads` 并行垃圾回收线程数
   - `ConcGCThreads` 并发垃圾回收线程数，建议设置为 `ParallelGCThreads`  的 1/4，如4核CPU，设置1个线程去进行垃圾回收，剩下3个留个用户线程去工作
   - `CMSInitiatingOccupancyFraction=percent` CMS 垃圾回收器在工作过程中，由于其它用户线程还可以继续运行，这时也可能产生垃圾，但是 并发清理  的同时不能把这些新的垃圾回收掉，所以就得等到下一次垃圾回收时才能清理，我们把这些垃圾称为 浮动垃圾，这时产生了新的问题，因为在垃圾回收时可能产生新的垃圾，它又不能像其它垃圾回收器那样，等到整个堆内存不足了再垃圾回收，那样的话，那些新垃圾就无处可放了，所以得预留一定空间保留这些浮动垃圾。这个参数就是控制我们何时进行垃圾回收的时机，参数类型是百分比，比如设置为：80。表示只有老年代的内存占用到达 80% 时，就执行一次垃圾回收
   - `CMSScavengeBeforeRemark` 在 **重新标记** 之前，对 新生代 进行垃圾回收。有可能 新生代的对象会引用老年代的对象，这时在 **重新标记**会扫描整个堆，然后通过新生代扫描引用老年代做可达性分析，但这样堆性能影响大，因为新生代创建的对象有点多，其中可能有很多都是垃圾对象 ，所以就算找到了，将来也要被回收掉，所以相当于做了一些无用功

4. 并发失败

由于该垃圾回收器采用 标记清除算法，所以可能产生较多的垃圾碎片，这样就会造成将来如果 分配对象时，经历一次 Minor GC后不足，由于老年代碎片过多也不足，这样就会造成 并发失败，及由于碎片过多造成并发失败，这时 `UseConcMarkSweepGC` 老年代垃圾回收器就不能正常工作了，这时`UseConcMarkSweepGC` 就会退化为 `SerialOld` ，做一次 单线程的、串行的 垃圾回收，清理完碎片才能继续工作。

如果发生并发失败了，垃圾回收时间就会邹增，导致本来是 响应时间优先 变成 响应时间过长

### 5、Garbage First（G1）

#### 1、简介

1. JDK9 默认的垃圾回收器

2. 适用场景

- 同时注重 吞吐量（Throughput）和 低延迟（Low latency），默认的暂停目标是 200ms。
     - 也可在垃圾回收线程运行的同时，其它用户线程继续运行
   - 超大堆内存，会将 堆 划分为多个大小相等的 Region（区域），每个  Region 都可作为独立的 Region，每个Region 都可以作为 伊甸园、幸存区、老年代 。
     - 与 `CMS` 垃圾回收器都属于 并发的垃圾回收器，在堆内存较小的情况下，暂停时间不相上下。但若随着堆内存越来越大，那么 `G1` 的优势就比  `CMS`  明显了
   - 整体上采用了：标记整理算法，避免产生垃圾碎片。两个Region之间是 复制 算法。

3. 相关 JVM 参数

```
   -XX:+UseG1GC	// jdk 1.8 不是默认的，需做设置
   -XX:+G1HeapRegionSize = size //划分区域
   -XX:MaxGCPauseMillis = time // 暂停目标时间
   ```

#### 2、G1垃圾回收阶段

![image-20211031145618892](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211031145627.png)

#### 3、G1-新生代回收

**Young Collection**

- 会 STW

![image-20211031145850613](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211031145851.png)

首先，G1 垃圾回收器会把整个堆内存划分成很多个 Region，每个 Region 都可以独立作为 伊甸园、幸存区、老年代，**白色框框** 表示 空闲的区域，当执行类加载时新创建的一些对象，就会分配到 **E 伊甸园** 区，随着  **E 伊甸园** 区被占满，会触发一次 **Young Collection**，这时也会 STW，当然这个时间比较短

![image-20211031150331002](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211031150332.png)

新生代垃圾回收就会把 幸存的对象，以 复制 算法放入 **幸存区S**

![image-20211031150516273](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211031150517.png)

随着对象的增多，幸存区 内存不足或者幸存区的对象超过一定年龄，又会触发 新生代垃圾回收，这时，幸存区一部分对象就会晋升到 **老年代O**，而不够年龄的幸存区对象，会继续 复制 到其它**幸存区S**

#### 4、Young Collection + CM

**定义：**新生代的垃圾回收和并发阶段

- 我们在进行垃圾回收时，需要进行 初始 标记和 并发标记。初始标记，就是要找到那些 GC Root（根对象），而 并发标记 就是从 RC Root（根对象）出发，顺着引用链找到其它对象。

- 初始标记 在 新生代垃圾回收 时就发生了，注意，初始标记并不会占用 并发标记 的时间

- 什么时候进行并发标记呢？当老年代占用堆空间达到一定阈值时，这时就会发生 并发标记（不会 STW），由以下 JVM 参数设置

- ```shell
  -XX:InitiatingHeapOccupancyPercent=percent(默认 45%)
  ```

![image-20211031151905965](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211031151907.png)

#### 5、Mixed Collection

会对 伊甸园、幸存区、老年代 进行全面垃圾回收

- 最终标记（Remark）会 STW
  - 防止之前 并发标记 中可能会漏掉一些对象，因为在并发标记的同时，其它用户线程也在工作，可能会产生一些新的垃圾，改变对象的引用，所以可能会被结果产生影响，所以需要在 Mixed Collection 阶段，先 STW，然后执行一个 最终标记
- 拷贝存活（Evacuation）会 STW

```
-XX:MaxGCPauseMillis=ms  最大暂停时间
```

![image-20211031152428272](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211031152429.png)

分析上图：

进行一次垃圾回收后，**伊甸园E** 的幸存对象 会被 复制 到 **幸存区S** ，另一些 **幸存区S** 的对象，不够年龄的也会被复制到 **幸存区S**，有一些符合晋升条件的就会晋升到 **老年代O**

经过几轮并发标记后，发现老年代O 里也有一些对象没用了，可以回收了。看上图，为什么没有把所有老年代O箭头都指向右下角那个老年代O呢？那是因为 G1垃圾回收器，会根据 `-XX:MaxGCPauseMillis=ms  最大暂停时间` ，进行有选择的垃圾回收，怎么理解呢？有时候我们堆内存空间很低，老年代的垃圾回收时间就可能会很长，因为采用的 复制 算法，有大量的对象要从一个 Region 复制到 另一个 Region，这时如果时间长了，就达不到 我们预期设置的 `-XX:MaxGCPauseMillis=ms  最大暂停时间`，那怎么办呢？为了达到这个设置的最大暂停时间，G1垃圾回收器就会从所有老年代中挑选回收价值最高的几个 Region，也就是这几个 Region 被回收后能释放更大的空间，所以就只会挑几个 Region，这时 Region 少了，最大暂停时间也就能达到了。当然，如果要复制的对象没那么多，最大暂停时间 这个目标也能达到，那么就会把所有 Region 都复制走，复制，一方面是为了保存 存活对象，另一方面是为了 整理， 减少内存空间。

这时就验证了 为什么要把这个垃圾回收器称为 ：G1，即优先回收垃圾最大的 Region。主要目的就是为了达到 最大暂停时间

**注意**

当 垃圾回收速度 < 垃圾产生速度 ，这时 并发收集 就失败了，这时就会退化为 串行 的收集，这时就称为 Full GC了。

#### 6、Young Collection 跨代引用

- 新生代回收的跨代引用（老年代引用新生代）问题

![image-20211031160546360](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211031160547.png)

我们先回忆一下新生代垃圾回收，首先就是找到 GC Root（根对象），然后 GC Root 进行可达性分析，再找到存活对象，存活对象进行 复制，复制到 幸存区。

这时就有一个问题，我们要找 新生代对象的 GC Root，通过 GC Root就行查找，那首先得找 GC Root，而 GC Root 又有一部分来自老年代，但老年代的存活对象又很多，如果我们通过遍历整个老年代找到根对象，显然效率很低，因此，采用了 **卡表（card table）** 的技术，把老年代的Region，再进行细分，分成一个个的 card，每个 card 分别为 512K ，如果老年代中有一个对象引用了新生代的对象，那么这个对应的 card 就标记为：脏卡。这样做的好处就是做 GC Root 遍历时 不用去遍历整个老年代，而是只需要去关注 脏卡 的区域就好了。

![image-20211031161440643](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211031161442.png)

上图中，粉色区域 代表 脏卡，它们都有对象引用新生代中的对象。

新生代中有一个 ：Remember Set，会记录外部对新生代区域的引用，也就是记录都有哪些 脏卡。将来对 新生代进行垃圾回收时，就可以通过 Remember Set 去知道有哪些脏卡，然后再到这些脏卡中，遍历 GC Root。这样就减少了 GC Root 的遍历时间。

在进行对象引用创建时，会有一个查找过程，查找该引用是否被其它区域对象所引用，若被引用，则在 Remember Set 集合中标注，也就是 脏卡

但这时又有一个问题，我们需要标记脏卡，这些脏卡其实是通过下面 `post-write barrier + dirty card queue //写屏障` ，在每次对象的引用发送变更时，都要去更新脏卡，即把卡表中的卡标记为 脏卡。这是一个 异步操作，即不会立刻完成脏卡的更新，会把更新指令放在脏卡的队列中，将来由一个线程完成脏卡的更新操作

**产生跨代引用（老年代引用新生代对象）的老年代区域称为脏卡区域**

#### 7、Remark(重新标记)

- pre-write barrier+satb_mark_queue

![image-20211101150213516](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211101150214.png)

上图表示的是：并发标记阶段，对象的处理状态

- 黑色：已处理完成，且有引用在引用它们，所以结束时会存活下来
- 灰色：正在处理，上图中 灰色 的方框被引用，所以最后还是会存活
- 白色：未处理，上图中右下角的 白色 的方框被引用，所以最后还是会存活，上面那个白色 因为无人引用，最后还是白色，还是会被回收

**案例一**

![image-20211101150639371](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211101150640.png)

假如现在处理到 灰色B ，因为有强引用引用它，所以，就把它变成黑色，将来会存活，当我们处理到 白色C 时，因为是 并发标记 ，就表示 可能会有 用户线程 对 白色C 的引用做修改，比如把 B-->C 的引用断开，所以处理 C 时，发现已经没被引用了，所以等整个 并发标记 完成后，C仍然是白色，最后就会被回收。

![image-20211101151230058](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211101151231.png)

**案例二**

1. 在 C 被处理完后，并发标记可能还没有结束，这时用户线程又改变 C 的引用地址，比如把 A--->C 。这时问题就来了，因为之前 C 已经被处理过了，且 A 是黑色的，所以也不会处理 A了，所以等到整个并发标记结束后，C就会漏处理了，但我们仍然认为 C 是白色的，要把其回收掉，但这样就错误了，为什么呢？这时候有一个强引用引用它，若再将其回收掉，这时伤害就大了，所以，需对对象的引用做进一步的检查，怎么做呢？其实就是 Remark，重新标记阶段。就是为了防止这种现象发生，那具体怎么做呢？

![image-20211101151428173](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211101151429.png)

2. 就是当对象的引用发送改变时，JVM 就会为其加入一个 写屏障。什么叫写屏障？ 只要你的对象引用发生改变，写屏障 的代码就会被执行，比如把 C的引用 给 A的一个属性，这说明 C的引用 发生了变化，既然发生变化，写屏障的代码就会被执行，那写屏障的指令做了什么呢？它就会把 A加入队列中，并且把 A 变成灰色，即表示还没处理完，等到整个 并发标记 结束了，接下来进入 重新标记 阶段，重新标记会 STW，让其它用户线程暂停，这时 重新标记 就会把 队列 中的对象一个个取出，再做一次检查，发现是 灰色的，还需进一步判断处理，结果发现有强引用，再把其变成黑色

![image-20211101152054679](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211101152055.png)

## 1.9 垃圾回收调优

官网

```
https://docs.oracle.com/en/java/javase/11/tools/
```

有时候不知道 自己用的哪个垃圾回收器、新生代大小等等也都不知道，下面的命令可查看 当前虚拟机的运行参数

```shell
"E:\Java\jdk\bin\java" -XX:+PrintFlagsFinal -version | findstr "GC"

//注意：E:\Java\jdk 是jdk 所在目录 ，后面 bin\java固定
```

![image-20211101210437275](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211101210446.png)

**预备知识**

- 掌握 GC 相关的 VM 参数，会基本的空间调整
- 掌握相关工具
- 明白一点：调优跟应用、环境有关，没有放之四海而皆准的法则

#### 1、调优领域

- 内存
- 锁竞争
- CPU  占用
- IO

#### 2、确定目标

- 【低延迟】还是【高吞吐量】，选择合适的垃圾回收器
- CMS、G1、ZGC
- ParallelGC
- Zing

#### 3、最快的 GC 是不发生 GC

- 查看 FullGC 前后的内存占用，考虑下面几个问题
  - 数据是不是太多？
    - resultSet = statement.executeQuery("select * from 大表 limit n")
  - 数据表示是否太臃肿？
    - 对象图
    - 对象大小 包装类 Integer 16字节  而int 4个字节
  - 是否存在内存内存泄漏
    - static Map map =   内存泄漏
    - 使用 软、弱引用
    - 第三方缓存实现

#### 4、新生代调优

在做内存调优之前，首先要排查是否是自己代码出现问题， 只有排除自己的代码问题后才能进行内存调优，而内存调优建议从：新生代 调优开始

新生代的特点：

- 所有的 new 操作的内存分配非常廉价
  - new 一个对象时，对象首先会在伊甸园中分配，这个分配速度很快，为什么很快呢？
  - TLAB thread-local allocation buffer。每个线程都会在伊甸园中为其分配一块私有的区域，即 TLAB，当new 一个对象时，首先会检查 TLAB 缓存区中是否有足够内存，如果有，会优先在 TLAB 中分配，为什么这么做？因为对象分配也有线程安全问题，比如 线程1 要用 A内存，那么在分配还没结束的过程中，线程2不能一上来就也要用 A内存，会造成内存分配混乱。因此在做对象内存分配时，也要做线程并发安全保护，当然这个操作由 JVM 解决。即 TLAB 减少线程之间对内存分配的并发冲突
- 死亡对象的回收代价为零
  - 我们都知道，前面几种垃圾回收器都是采用复制算法，复制算法的特点，就是把伊甸园、幸存区From中的幸存对象复制到幸存区To 中，复制完后，伊甸园、幸存区From的内存也被释放出来了，因此死亡对象的回收代价为零。
- 大部分对象都是用过即死
  - 当垃圾回收时，新生代绝大多数对象都会被回收，只有少部分存活
- Minor GC 的时间远远低于 Full GC
  - 幸存对象已经很少了，又采用 复制 算法

**如何对新生代进行调优呢？**

适当调整新生代大小。

- 新生代太小，可用空间就少，创建新对象时一旦发现空间不足，就会触发 Minor GC，而 Minor GC 一触发就会 STW。

- 新生代太大，老年代的可用空间就变少了，但新生代会认为内存空间仍很多，将来老年代空间紧张了，再触发垃圾回收就少 Full GC了，STW 会比 Minor GC 暂停时间更长

- Oracle 官方给出：新生代空间大于整个堆空间的 25%，小于整个堆的 50%

- 25%《 新生代《 50%
  - ![image-20211101222618072](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211101222619.png)

- 新生代空间越大，吞吐量会随之增高，但到达一定程序后，会下降，为什么呢？因为空间大了，就意味着回收的时间会变长，打个比方，一栋楼很大，打扫垃圾时间就会更长

![image-20211101222604304](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211101222605.png)

- 新生代的内存设置

新生代垃圾回收都是复制算法，而复制算法也分两个阶段，标记 + 复制，而 复制 要牵扯到对象占用内存块移动、更新其它引用地址等等，所以会耗时多些，而新生代的对象 绝大部分都是古稀之年，也就是最终只有少量对象，所以复制 所占用的时间其实也是很短的，所以 标记 的时间相对于 复制 就显得不那么重要了，那究竟把新生代内存设为多大比较合适

比如有一次请求相应，一次响应又可能产生很多新对象，那这些新对象加起来比如占到 512K 的内存，假设我的并发量是 1000，那么这时 新生代的理想内存就是

```
并发量 * (请求响应占用内存) = 1000 * 512K = 512M
```

- 幸存区的内存设置

- 幸存区大到能保留【当前活跃对象 + 需要晋升的对象】，什么意思呢？幸存区可以看做有两类对象，，第一类生命周期较短，也许下一次垃圾回收就把它回收掉了，但是由于现在仍在使用它，暂时不能回收所以就将其留在幸存区中。另一类是将来会被晋升到老年代，因为大家都在用它，但是由于年龄仍不够，所以暂时也存在幸存区中，那么幸存区就可以看成是这两类对象
  - 若幸存区内存较小，JVM会动态调整晋升阈值，那这样有什么问题呢？假如一个存活时间短的对象，被提前晋升到老年代，那就意味着它得等到老年代的空间不足时触发 Full GC 才能把它当成垃圾进行回收，所以这就变相延长了对象的生存时间

- 晋升阈值配置得当，让长时间存活对象尽快晋升

```
  -XX:MaxTenuringThreshold=threshold
  调整最大晋升阈值
  
  -XX:+PrintTenuringDistribution
  打印晋升详情信息，便于判断
  ```

![image-20211101232436234](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211101232437.png)

#### 5、案例

1. Full GC 和 Minor GC 频繁发生

解决：适当增加新生代内存空间，同时幸存区空间也增大，晋升阈值也增加，这样就可以让很多生命周期较短的对象尽可能被留在新生代，这样老年代中就存在很少或者没有生命周期短的对象，就减少了 Full GC

2. 请求高峰期发生 Full GC，单次暂停时间特别长（CMS）

因为要求低延迟，所以选择 CMS 垃圾回收器，因为确定使用 CMS 垃圾回收器，所以就可以查看 GC 日志，看看 CMS 哪个阶段耗费时间较长，一般都是 重新标记 阶段耗费较长时间，所以可通过在 重新标记 之前对新生代的垃圾对象进行清理，清理后存活对象少了，需要查找和标记的对象就少了，这样就可以解决该问题

```
   -XX:+CMSScavengeBeforeRemark
   ```

3. 老年代空间充裕条件下，发生 Full GC（CMS）

之前了解到，CMS 有可能因为空间不足导致并发失败或者空间碎片比较多都会产生 Full GC，但是通过排查，都没有产生空间不足、碎片过多等提示，这就说明老年代空间是充裕的

而在 jdk1.7 由于永久代空间不足，也会产生 Full GC，而 jdk1.8后，改成元空间，所以垃圾回收就不是由 java 控制了，默认情况下，元空间使用操作系统的内存空间，所以空间容量比较充裕，一般不会产生内存不足

# 四、类加载与字节码技术

## 1、类文件结构

一个简单的 HelloWorld.java

```java
// HelloWorld 示例 
public class HelloWorld {
	public static void main(String[] args) { 
		System.out.println("hello world");
    } 
}
```

执行 javac -parameters -d .HelloWorld.java

```
javac是编译 -d是打包 .是代表当前目录 HelloWorld.java是要编译的java程序
你在cmd下你输入的命令肯定是有目录的.比如前面是C:\>那么你所输入的命令就代表在c盘根目录下进行操作.如果你想要把生成的.class文件放在其他位置比如d盘根目录,那么命令就变为javac -d d:\ HelloWorld.java
```

编译为 HelloWorld.class 后是这样的

![image-20211103143639903](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211103143648.png)

根据 JVM 规范，类文件结构如下

![image-20211103143727331](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211103143728.png)

### 1.1 魔数

0~3 字节，表示它是否是【class】类型的文件

0000000 **ca fe ba be** 00 00 00 34 00 23 0a 00 06 00 15 09

### 1.2 版本

4~7 字节，表示类的版本 00 34（52） 表示是 Java 8

0000000 ca fe ba be 00 00 **00 34** 00 23 0a 00 06 00 15 09

52对应 JDK8  53对应 JDK9 以此类推

34 是十六进制，转为 十进制 就是 52

### 1.3 常量池

![image-20211103150116939](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211103150118.png)

8~9字节，表示常量池长度，00  23（35）表示常量池有  #1~#34项，注意，#0项不计入，也没有值。

还是和上面一样，23是十六进制，转为十进制就是 35

0000000 ca fe ba be 00 00 00 34 **00 23** 0a 00 06 00 15 09

第 #1 项 0a（十六进制转为十进制是10，然后查表）表示一个 Method 信息，00  06 和 00  15（十六进制转为十进制是21）表示它引用了 常量池 #6 和 #21 项来获得这个方法的 【所属类】和【方法名】

0000000 ca fe ba be 00 00 00 34 00 23 **0a 00 06 00 15** 09

第#2项 09 表示一个 Field 信息，00 16（22）和 00 17（23） 表示它引用了常量池中 #22 和 # 23 项

来获得这个成员变量的【所属类】和【成员变量名】

0000000 ca fe ba be 00 00 00 34 00 23 0a 00 06 00 15 **09**

0000020 **00 16 00 17** 08 00 18 0a 00 19 00 1a 07 00 1b 07

第#3项 08 表示一个字符串常量名称，00 18（24）表示它引用了常量池中 #24 项

0000020 00 16 00 17 **08 00 18** 0a 00 19 00 1a 07 00 1b 07

第#4项 0a 表示一个 Method 信息，00 19（25） 和 00 1a（26） 表示它引用了常量池中 #25 和 #26

项来获得这个方法的【所属类】和【方法名】

0000020 00 16 00 17 08 00 18 **0a 00 19 00 1a** 07 00 1b 07

第#5项 07 表示一个 Class 信息，00 1b（27） 表示它引用了常量池中 #27 项

0000020 00 16 00 17 08 00 18 0a 00 19 00 1a **07 00 1b** 07

第#6项 07 表示一个 Class 信息，00 1c（28） 表示它引用了常量池中 #28 项

0000020 00 16 00 17 08 00 18 0a 00 19 00 1a 07 00 1b **07**

0000040 **00 1c** 01 00 06 3c 69 6e 69 74 3e 01 00 03 28 29

第#7项 01 表示一个 utf8 串，00 06 表示长度，3c 69 6e 69 74 3e 是【 <init> 】，即代表 Object 的构造方法

0000040 00 1c **01 00 06 3c 69 6e 69 74 3e** 01 00 03 28 29

第#8项 01 表示一个 utf8 串，00 03 表示长度，28 29 56 是【**()V**】其实就是表示无参、无返回值

0000040 00 1c 01 00 06 3c 69 6e 69 74 3e **01 00 03 28 29**

0000060 **56** 01 00 04 43 6f 64 65 01 00 0f 4c 69 6e 65 4e

第#9项 01 表示一个 utf8 串，00 04 表示长度，43 6f 64 65 是【Code】

0000060 56 **01 00 04 43 6f 64 65** 01 00 0f 4c 69 6e 65 4e

第#10项 01 表示一个 utf8 串，00 0f（15） 表示长度，4c 69 6e 65 4e 75 6d 62 65 72 54 61 62 6c 65

是【LineNumberTable】

0000060 56 01 00 04 43 6f 64 65 **01 00 0f 4c 69 6e 65 4e**

0000100 **75 6d 62 65 72 54 61 62 6c 65** 01 00 12 4c 6f 63

第#11项 01 表示一个 utf8 串，00 12（18） 表示长度，4c 6f 63 61 6c 56 61 72 69 61 62 6c 65 54 61

62 6c 65是【LocalVariableTable】

0000100 75 6d 62 65 72 54 61 62 6c 65 **01 00 12 4c 6f 63**

0000120 **61 6c 56 61 72 69 61 62 6c 65 54 61 62 6c 65** 01

第#12项 01 表示一个 utf8 串，00 04 表示长度，74 68 69 73 是【this】

0000120 61 6c 56 61 72 69 61 62 6c 65 54 61 62 6c 65 **01**

0000140 **00 04 74 68 69 73** 01 00 1d 4c 63 6e 2f 69 74 63

第#13项 01 表示一个 utf8 串，00 1d（29） 表示长度，是【Lcn/itcast/jvm/t5/HelloWorld;】

0000140 00 04 74 68 69 73 **01 00 1d 4c 63 6e 2f 69 74 63**

0000160 **61 73 74 2f 6a 76 6d 2f 74 35 2f 48 65 6c 6c 6f**

0000200 **57 6f 72 6c 64 3b** 01 00 04 6d 61 69 6e 01 00 16

第#14项 01 表示一个 utf8 串，00 04 表示长度，74 68 69 73 是【main】

0000200 57 6f 72 6c 64 3b **01 00 04 6d 61 69 6e** 01 00 16

第#15项 01 表示一个 utf8 串，00 16（22） 表示长度，是【([Ljava/lang/String;)V】其实就是参数为

字符串数组，无返回值

0000200 57 6f 72 6c 64 3b 01 00 04 6d 61 69 6e **01 00 16**

0000220 **28 5b 4c 6a 61 76 61 2f 6c 61 6e 67 2f 53 74 72**

0000240 **69 6e 67 3b 29 56** 01 00 04 61 72 67 73 01 00 13

第#16项 01 表示一个 utf8 串，00 04 表示长度，是【args】

0000240 69 6e 67 3b 29 56 01 00 04 61 72 67 73 01 00 13

第#17项 01 表示一个 utf8 串，00 13（19） 表示长度，是【[Ljava/lang/String;】

0000240 69 6e 67 3b 29 56 01 00 04 61 72 67 73 01 00 13

0000260 5b 4c 6a 61 76 61 2f 6c 61 6e 67 2f 53 74 72 69

0000300 6e 67 3b 01 00 10 4d 65 74 68 6f 64 50 61 72 61

第#18项 01 表示一个 utf8 串，00 10（16） 表示长度，是【MethodParameters】

0000300 6e 67 3b 01 00 10 4d 65 74 68 6f 64 50 61 72 61

0000320 6d 65 74 65 72 73 01 00 0a 53 6f 75 72 63 65 46

第#19项 01 表示一个 utf8 串，00 0a（10） 表示长度，是【SourceFile】

0000320 6d 65 74 65 72 73 01 00 0a 53 6f 75 72 63 65 46

0000340 69 6c 65 01 00 0f 48 65 6c 6c 6f 57 6f 72 6c 64

第#20项 01 表示一个 utf8 串，00 0f（15） 表示长度，是【HelloWorld.java】

0000340 69 6c 65 01 00 0f 48 65 6c 6c 6f 57 6f 72 6c 64

0000360 2e 6a 61 76 61 0c 00 07 00 08 07 00 1d 0c 00 1e

第#21项 0c 表示一个 【名+类型】，00 07 00 08 引用了常量池中 #7 #8 两项

0000360 2e 6a 61 76 61 **0c 00 07 00 08** 07 00 1d 0c 00 1e

第#22项 07 表示一个 Class 信息，00 1d（29） 引用了常量池中 #29 项

0000360 2e 6a 61 76 61 0c 00 07 00 08 **07 00 1d** 0c 00 1e

第#23项 0c 表示一个 【名+类型】，00 1e（30） 00 1f （31）引用了常量池中 #30 #31 两项

0000360 2e 6a 61 76 61 0c 00 07 00 08 07 00 1d **0c 00 1e**

0000400 **00 1f** 01 00 0b 68 65 6c 6c 6f 20 77 6f 72 6c 64

第#24项 01 表示一个 utf8 串，00 0f（15） 表示长度，是【hello world】

0000400 00 1f **01 00 0b 68 65 6c 6c 6f 20 77 6f 72 6c 64**

第#25项 07 表示一个 Class 信息，00 20（32） 引用了常量池中 #32 项

0000420 **07 00 20** 0c 00 21 00 22 01 00 1b 63 6e 2f 69 74

第#26项 0c 表示一个 【名+类型】，00 21（33） 00 22（34）引用了常量池中 #33 #34 两项

0000420 07 00 20 **0c 00 21 00 22** 01 00 1b 63 6e 2f 69 74

第#27项 01 表示一个 utf8 串，00 1b（27） 表示长度，是【cn/itcast/jvm/t5/HelloWorld】

0000420 07 00 20 0c 00 21 00 22 01 00 1b 63 6e 2f 69 74

0000440 63 61 73 74 2f 6a 76 6d 2f 74 35 2f 48 65 6c 6c

0000460 6f 57 6f 72 6c 64 01 00 10 6a 61 76 61 2f 6c 61

第#28项 01 表示一个 utf8 串，00 10（16，即 6a~74） 表示长度，是【java/lang/Object】

0000460 6f 57 6f 72 6c 64 **01 00 10 6a 61 76 61 2f 6c 61**

0000500 **6e 67 2f 4f 62 6a 65 63 74** 01 00 10 6a 61 76 61

第#29项 01 表示一个 utf8 串，00 10（16） 表示长度，是【java/lang/System】

0000500 6e 67 2f 4f 62 6a 65 63 74 01 00 10 6a 61 76 61

0000520 2f 6c 61 6e 67 2f 53 79 73 74 65 6d 01 00 03 6f

第#30项 01 表示一个 utf8 串，00 03 表示长度，是【out】

0000520 2f 6c 61 6e 67 2f 53 79 73 74 65 6d **01 00 03 6f**

0000540 **75 74** 01 00 15 4c 6a 61 76 61 2f 69 6f 2f 50 72

第#31项 01 表示一个 utf8 串，00 15（21） 表示长度，是【Ljava/io/PrintStream;】

0000540 75 74 **01 00 15 4c 6a 61 76 61 2f 69 6f 2f 50 72**

0000560 **69 6e 74 53 74 72 65 61 6d 3b** 01 00 13 6a 61 76

第#32项 01 表示一个 utf8 串，00 13（19） 表示长度，是【java/io/PrintStream】

0000560 69 6e 74 53 74 72 65 61 6d 3b **01 00 13 6a 61 76**

0000600 **61 2f 69 6f 2f 50 72 69 6e 74 53 74 72 65 61 6d**

第#33项 01 表示一个 utf8 串，00 07 表示长度，是【println】

0000620 01 00 07 70 72 69 6e 74 6c 6e 01 00 15 28 4c 6a

第#34项 01 表示一个 utf8 串，00 15（21） 表示长度，是【(Ljava/lang/String;)V】

0000620 01 00 07 70 72 69 6e 74 6c 6e 01 00 15 28 4c 6a

0000640 61 76 61 2f 6c 61 6e 67 2f 53 74 72 69 6e 67 3b

0000660 29 56 00 21 00 05 00 06 00 00 00 00 00 02 00 01

看了一遍，大概知道，常量池里，其实就是记录了 Java 类中的各种信息，包括类的信息、父类的信息、方法的信息、成员变量的信息、方法的属性等。

### 1.4 访问标识与继承信息

21（20+1） 表示该 class 是一个类，公共的

0000660 29 56 **00 21** 00 05 00 06 00 00 00 00 00 02 00 01

05 表示根据常量池中 #5 找到本类全限定名

0000660 29 56 00 21 **00 05** 00 06 00 00 00 00 00 02 00 01

06 表示根据常量池中 #6 找到父类全限定名

0000660 29 56 00 21 00 05 **00 06** 00 00 00 00 00 02 00 01

表示接口的数量，本类为 0

0000660 29 56 00 21 00 05 00 06 **00 00** 00 00 00 02 00 01

![image-20211103153659659](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211103153700.png)

### 1.5 Filed 信息

表示成员变量数量，本类为 0

0000660 29 56 00 21 00 05 00 06 00 00 **00 00** 00 02 00 01

![image-20211103154040980](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211103154042.png)

蚌不住了

## 2、字节码指令

### 1、javap 工具

前面的天坑别看了 看不懂的

使用 Oracle 提供的 javap 工具反编译 class 文件

`javap -v HelloWorld.class`

```shell
Classfile /E:/IDEA/workspace/aliabab-TheardConcurrent/target/classes/com/alibaba/rubbish/HelloWorld.class
  Last modified 2021-11-3; size 573 bytes
  MD5 checksum be8f4ad72cd0e936ed1a63d9fb62afaa
  Compiled from "HelloWorld.java"
public class com.alibaba.rubbish.HelloWorld
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Methodref          #6.#20         // java/lang/Object."<init>":()V
   #2 = Fieldref           #21.#22        // java/lang/System.out:Ljava/io/PrintStream;
   #3 = String             #23            // Hello World
   #4 = Methodref          #24.#25        // java/io/PrintStream.println:(Ljava/lang/String;)V
   #5 = Class              #26            // com/alibaba/rubbish/HelloWorld
   #6 = Class              #27            // java/lang/Object
   #7 = Utf8               <init>
   #8 = Utf8               ()V
   #9 = Utf8               Code
  #10 = Utf8               LineNumberTable
  #11 = Utf8               LocalVariableTable
  #12 = Utf8               this
  #13 = Utf8               Lcom/alibaba/rubbish/HelloWorld;
  #14 = Utf8               main
  #15 = Utf8               ([Ljava/lang/String;)V
  #16 = Utf8               args
  #17 = Utf8               [Ljava/lang/String;
  #18 = Utf8               SourceFile
  #19 = Utf8               HelloWorld.java
  #20 = NameAndType        #7:#8          // "<init>":()V
  #21 = Class              #28            // java/lang/System
  #22 = NameAndType        #29:#30        // out:Ljava/io/PrintStream;
  #23 = Utf8               Hello World
  #24 = Class              #31            // java/io/PrintStream
  #25 = NameAndType        #32:#33        // println:(Ljava/lang/String;)V
  #26 = Utf8               com/alibaba/rubbish/HelloWorld
  #27 = Utf8               java/lang/Object
  #28 = Utf8               java/lang/System
  #29 = Utf8               out
  #30 = Utf8               Ljava/io/PrintStream;
  #31 = Utf8               java/io/PrintStream
  #32 = Utf8               println
  #33 = Utf8               (Ljava/lang/String;)V
{
  public com.alibaba.rubbish.HelloWorld();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=1, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
         4: return
      LineNumberTable:
        line 3: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       5     0  this   Lcom/alibaba/rubbish/HelloWorld;

public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=1, args_size=1
         0: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
         3: ldc           #3                  // String Hello World
         5: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
         8: return
      LineNumberTable:
        line 6: 0
        line 7: 8
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       9     0  args   [Ljava/lang/String;
}
SourceFile: "HelloWorld.java"

```

### 2、图解方法执行流程

1. 原始 Java 代码

```java
   package com.alibaba.classloader;
   /**
    * 演示 字节码 指令 和 操作数栈、常量池 的关系
    */
   public class Demo3_1 {
       public static void main(String[] args) {
           int a = 10;
           int b = Short.MAX_VALUE + 1;
           int c = a + b;
           System.out.println(c);
       }
   }
   ```

2. 编辑后的字节码文件

```shell
   Classfile /E:/IDEA/workspace/aliabab-TheardConcurrent/target/classes/com/alibaba/classloader/Demo3_1.class
     Last modified 2021-11-3; size 631 bytes
     MD5 checksum 674f0e77f2bacca6947a8d93cbba49dc
     Compiled from "Demo3_1.java"
   public class com.alibaba.classloader.Demo3_1
     minor version: 0
     major version: 52
     flags: ACC_PUBLIC, ACC_SUPER
   Constant pool:
      #1 = Methodref          #7.#25         // java/lang/Object."<init>":()V
      #2 = Class              #26            // java/lang/Short
      #3 = Integer            32768
      #4 = Fieldref           #27.#28        // java/lang/System.out:Ljava/io/PrintStream;
      #5 = Methodref          #29.#30        // java/io/PrintStream.println:(I)V
      #6 = Class              #31            // com/alibaba/classloader/Demo3_1
      #7 = Class              #32            // java/lang/Object
      #8 = Utf8               <init>
      #9 = Utf8               ()V
     #10 = Utf8               Code
     #11 = Utf8               LineNumberTable
     #12 = Utf8               LocalVariableTable
     #13 = Utf8               this
     #14 = Utf8               Lcom/alibaba/classloader/Demo3_1;
     #15 = Utf8               main
     #16 = Utf8               ([Ljava/lang/String;)V
     #17 = Utf8               args
     #18 = Utf8               [Ljava/lang/String;
     #19 = Utf8               a
     #20 = Utf8               I
     #21 = Utf8               b
     #22 = Utf8               c
     #23 = Utf8               SourceFile
     #24 = Utf8               Demo3_1.java
     #25 = NameAndType        #8:#9          // "<init>":()V
     #26 = Utf8               java/lang/Short
     #27 = Class              #33            // java/lang/System
     #28 = NameAndType        #34:#35        // out:Ljava/io/PrintStream;
     #29 = Class              #36            // java/io/PrintStream
     #30 = NameAndType        #37:#38        // println:(I)V
     #31 = Utf8               com/alibaba/classloader/Demo3_1
     #32 = Utf8               java/lang/Object
     #33 = Utf8               java/lang/System
     #34 = Utf8               out
     #35 = Utf8               Ljava/io/PrintStream;
     #36 = Utf8               java/io/PrintStream
     #37 = Utf8               println
     #38 = Utf8               (I)V
   {
     public com.alibaba.classloader.Demo3_1();
       descriptor: ()V
       flags: ACC_PUBLIC
       Code:
         stack=1, locals=1, args_size=1
            0: aload_0
            1: invokespecial #1                  // Method java/lang/Object."<init>":()V
            4: return
         LineNumberTable:
           line 6: 0
         LocalVariableTable:
           Start  Length  Slot  Name   Signature
               0       5     0  this   Lcom/alibaba/classloader/Demo3_1;
   
     public static void main(java.lang.String[]);
       descriptor: ([Ljava/lang/String;)V
       flags: ACC_PUBLIC, ACC_STATIC
       Code:
         stack=2, locals=4, args_size=1
            0: bipush        10
            2: istore_1
            3: ldc           #3                  // int 32768
            5: istore_2
            6: iload_1
            7: iload_2
            8: iadd
            9: istore_3
           10: getstatic     #4                  // Field java/lang/System.out:Ljava/io/PrintStream;
           13: iload_3
           14: invokevirtual #5                  // Method java/io/PrintStream.println:(I)V
           17: return
         LineNumberTable:
           line 8: 0
           line 9: 3
           line 10: 6
           line 11: 10
           line 12: 17
         LocalVariableTable:
           Start  Length  Slot  Name   Signature
               0      18     0  args   [Ljava/lang/String;
               3      15     1     a   I
               6      12     2     b   I
              10       8     3     c   I
   }
   SourceFile: "Demo3_1.java"
   ```

3. 那么，当这段 Java 代码被执行时，都发生了什么呢？它会由 Java 虚拟机的类加载器，把 main() 方法所在的类，进行一个类加载的操作，类加载其实就是把 上面的 .class 文件 那些字节码读取到内存中

其中，常量池中的数据会放入 运行时常量池 中，那什么叫 运行时常量池 呢？之前 内存结构 这一章讲过，整个 Java 虚拟机内存分成：栈、堆、方法区，而其实 运行时常量池 属于 方法区 的一部分，只是因为其比较特殊，所以单独拎出来，其实就是把 .class 文件常量池中的数据将来都存储在运行时常量池的地方，将来找其中一些 方法引用、成员变量引用、还有些具体数值，就到 运行时常量池 中找，下图中，只列出其中几项。

**1、常量池载入运行时常量池**

![image-20211103171348705](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211103171349.png)

分析 运行时常量池中 `#3 = Integer  32768`，那么这个 32768 代表谁呢？看 Java 源码，其实像一些比较小的数字，它并不是存储在常量池中，而是跟着方法的字节码指令存储在一起，而一旦这个数字的范围超过了整数的最大值，`Short.MAX_VALUE + 1` 故意让整数最大值 加 1，就超过了整数的最大值，其就会存储在常量池中

`#4 = Fieldref  java/lang/System.out:Ljava/io/PrintStream;` 成员变量信息，对应 System.out 这个成员变量

`#5 = Methodref  // java/io/PrintStream.println:(I)V` Methodref 这个信息，一个 println方法，(I)代表接收一个基本类型为整数类型的，v 表示返回值为 void

**2、方法字节码载入方法区**

![image-20211103172412096](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211103172413.png)

方法的字节码会放入方法区，其实就是 main() 方法中那些字节码指令都会存入 方法区

接下来 就是 main() 方法准备运行了

**3、main 线程开始运行，分配栈帧内存**

![image-20211103172633228](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211103172634.png)

在 main() 运行之前，会启动一个 main 主线程，启动主线程后就会为其分配一块 栈帧内存，上图中 栈帧内存又有两块区域，绿色的代表 局部变量表，浅蓝色的代表 操作数栈，它们各种多少呢，查看 .class 文件，`stack=2, locals=4` ，操作数栈用来存储 数据和字节码指令

小的数字跟字节码指令存在方法区，超过了 Short 范围的数字，就存入常量池中

**4、执行引擎开始执行字节码**

字节码执行流程

第一行代码是 **bipush 10**

执行引擎读到第一行代码，开始执行，那么 **bipush 10** 的作用是什么呢？

- 将一个 byte 压入操作数栈，而 10 是 属于 -128~127 之间所以属于 byte，所以用的指令是 **bipush 10**，这里需注意，操作数栈的 宽度 是 4个字节，而 byte 只有 1个字节，所以操作数栈会把剩下的 3个字节用 0或1 补齐，如果是正数就用0补齐，类似的指令还有如下：
- **sipush** 将一个 short 压入操作数栈，
- **ldc** 将一个 int 压入操作数栈，
- **ldc2_w** 将一个 long 压入操作数栈（分两次压入，因为 long 是8个字节）
-  **bipush 10** 把 10 这个数字，放入 操作数栈 中

![image-20211103174448012](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211103174450.png)

**istore_1**

- 将 操作数栈 栈顶元素弹出，存入局部变量表的 slot 1，1代表存入 1号 槽位

![image-20211103174910193](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211103174911.png)

![image-20211103174956558](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211103174957.png)

**ldc  #3**

- 超过 Short整数 范围，所以存储的位置是 运行时常量池中
- 从 运行时常量池 中取出的数据，放入 操作数栈，
- 注意：Short.MAX_VALUE 是 32767，所以 32768 = Short.MAX_VALUE + 1 实际是在编译期间计算好的，这也算一种优化， 即 常量折叠优化

![image-20211103175515214](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211103175516.png)

**istore_2**

- 将 操作数栈 栈顶元素弹出，存入局部变量表的 slot 2，2代表存入 2号 槽位

![image-20211103183555178](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211103183556.png)

执行的结果就是为 b变量赋值 32768

![image-20211103183609906](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211103183610.png)

接下来就是 a+b，这个操作也必须在操作数栈中完成，即在局部变量表中不能直接执行 a+b，所以，执行引擎会把 a、b 两个变量进行读取

**iload_1**

![image-20211103183938120](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211103183939.png)

**iload_2**

![image-20211103183957922](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211103183959.png)

读取完毕，即操作数栈有两个数了，这时执行引擎执行一个 iadd 了，会将 操作数栈 的变量弹出，并再次把结果存入 操作数栈

**iadd**

![image-20211103184352705](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211103184353.png)

![image-20211103184406456](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211103184407.png)

**istore_3**

![image-20211103184459950](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211103184500.png)

![image-20211103184522008](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211103184522.png)

**getstatic #4**

到 运行时常量池 中找到 成员变量的引用，即 `System.out` ，而  `System.out`  存储在 堆内存 中，所以 **getstatic #4** 就是通过 常量池 先找到 堆 中的对象，但是找到该对象后并不是先把这个对象放入 操作数栈，**getstatic #4** 只是获取它的引用，所以执行完 **getstatic #4** 后，就会把 堆 中的   `System.out` 对象的引用地址放入 操作数栈 中

![image-20211103185044481](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211103185045.png)

![image-20211103185059523](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211103185100.png)

**iload_3**

因为要执行一个打印操作，**iload_3** 把 常量池中 3号 槽位的值读入 操作数栈中

![image-20211103185226213](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211103185227.png)

![image-20211103185241693](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211103185242.png)

**invokevirtual #5**

- 到 常量池 中找到 5号位置，`#5 = Methodref // java/io/PrintStream.println:(I)V` 表示要执行一个方法，哪个方法呢？即 PrintStream类中的 println() 方法，注意，每次调用方法都会产生一个栈帧，所以，println() 方法执行时，又会定位到 方法区 的新的方法，新的方法再由虚拟机为其分配一个新的栈帧。接下来会开始执行，执行时会把 `32778` 这个栈顶信息**作为参数传递给新的栈帧**，pintln(I)，接收一个整形参数，这就真正完成打印操作，等方法执行结束，会把栈帧从栈里弹出
- 定位到方法区 `java/io/PrintStream.println:(I)V` 方法
- 生成新的栈帧（分配 locals、stack等）
- 传递参数，执行新栈帧中的字节码

![image-20211103190040539](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211103190041.png)

执行完毕，弹出栈帧，清除 main 操作数栈内容

![image-20211103190150431](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211103190151.png)

**return**

完成 main 方法的调用，弹出 main 栈帧

程序结束

### 3、练习 分析 i++

**目的：**从源码角度分析  a++

```java
package com.alibaba.classloader;

/**
 * 从字节码角度分析 a++
 */
public class Demo3_2 {
    public static void main(String[] args) {
        int a = 10;
        int b = a++ + ++a + a--;
        System.out.println(a);//11
        System.out.println(b);//34
    }
}
```

字节码 `javap -v Demo3_2.class `

```shell
Classfile /E:/IDEA/workspace/aliabab-TheardConcurrent/target/classes/com/alibaba/classloader/Demo3_2.class
  Last modified 2021-11-3; size 606 bytes
  MD5 checksum 8a4d0a81f449cdb24bc3c8cb5d90ef1a
  Compiled from "Demo3_2.java"
public class com.alibaba.classloader.Demo3_2
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Methodref          #5.#22         // java/lang/Object."<init>":()V
   #2 = Fieldref           #23.#24        // java/lang/System.out:Ljava/io/PrintStream;
   #3 = Methodref          #25.#26        // java/io/PrintStream.println:(I)V
   #4 = Class              #27            // com/alibaba/classloader/Demo3_2
   #5 = Class              #28            // java/lang/Object
   #6 = Utf8               <init>
   #7 = Utf8               ()V
   #8 = Utf8               Code
   #9 = Utf8               LineNumberTable
  #10 = Utf8               LocalVariableTable
  #11 = Utf8               this
  #12 = Utf8               Lcom/alibaba/classloader/Demo3_2;
  #13 = Utf8               main
  #14 = Utf8               ([Ljava/lang/String;)V
  #15 = Utf8               args
  #16 = Utf8               [Ljava/lang/String;
  #17 = Utf8               a
  #18 = Utf8               I
  #19 = Utf8               b
  #20 = Utf8               SourceFile
  #21 = Utf8               Demo3_2.java
  #22 = NameAndType        #6:#7          // "<init>":()V
  #23 = Class              #29            // java/lang/System
  #24 = NameAndType        #30:#31        // out:Ljava/io/PrintStream;
  #25 = Class              #32            // java/io/PrintStream
  #26 = NameAndType        #33:#34        // println:(I)V
  #27 = Utf8               com/alibaba/classloader/Demo3_2
  #28 = Utf8               java/lang/Object
  #29 = Utf8               java/lang/System
  #30 = Utf8               out
  #31 = Utf8               Ljava/io/PrintStream;
  #32 = Utf8               java/io/PrintStream
  #33 = Utf8               println
  #34 = Utf8               (I)V
{
  public com.alibaba.classloader.Demo3_2();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=1, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
         4: return
      LineNumberTable:
        line 6: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       5     0  this   Lcom/alibaba/classloader/Demo3_2;

public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=3, args_size=1
         0: bipush        10
         2: istore_1
         3: iload_1
         4: iinc          1, 1
         7: iinc          1, 1
        10: iload_1
        11: iadd
        12: iload_1
        13: iinc          1, -1
        16: iadd
        17: istore_2
        18: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
        21: iload_1
        22: invokevirtual #3                  // Method java/io/PrintStream.println:(I)V
        25: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
        28: iload_2
        29: invokevirtual #3                  // Method java/io/PrintStream.println:(I)V
        32: return
      LineNumberTable:
        line 8: 0
        line 9: 3
        line 10: 18
        line 11: 25
        line 12: 32
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      33     0  args   [Ljava/lang/String;
            3      30     1     a   I
           18      15     2     b   I
}
SourceFile: "Demo3_2.java"

```

**分析**

- 注意 iinc 指令是直接在局部变量 slot 上进行运算
- a++ 是先执行 iload 再执行 iinc
- ++a 是先执行 iinc 再执行 iload

**执行流程**

**bipish 10**

把 10 放入 操作数栈

![image-20211103194348501](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211103194350.png)

**istore_1**

把 10 从操作数栈的栈顶弹出，放入 局部变量表 的1号槽，对应代码中 a = 10

![image-20211103194611324](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211103194612.png)

开始执行 a++，刚刚说了，a++ 是先 iload 再 iinc

**iload_1**

把 局部变量表 中 1号槽 的值读取到 操作数栈 中，即先做读取

![image-20211103194811234](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211103194812.png)

**iinc  1,1**

**iinc  1,1** 有两个参数，第一个参数表明要对哪个槽位做 自增，第二个 槽位表明要 自增多少。

所以 执行引擎 执行 完这条指令，会把 局部变量表 1号槽 的变量做 自增 操作，也就是变成 11。

但要注意，该操作是直接在 局部变量表中执行 ，并没有影响到 操作数栈

![image-20211103195057115](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211103195058.png)

**iinc  1,1**

先自增，再 iload，所以 局部变量表 1号槽位自增 1，变成12

![image-20211103195330478](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211103195331.png)

**iload_1**

把 12 加入 操作数栈

![image-20211103195458341](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211103195459.png)

**iadd**

先把 操作数栈 的对象弹出，再执行 iadd，然后再入栈

![image-20211103195544689](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211103195545.png)

**iload_1**

![image-20211103195721574](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211103195722.png)

**iinc  1,-1**

![image-20211103195753520](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211103195754.png)

**iadd**

![image-20211103195822336](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211103195823.png)

**istore  2**

![image-20211103195849617](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211103195850.png)

### 4、条件判断指令

![image-20211103203900614](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211103203901.png)

几点说明：

- byte、short、char 都会按 int 比较，因为操作数栈都是 4 字节
- goto 用来进行跳转到指定行号的字节码

```java
public static void main(String[] args) {
        int a = 0;
        if(a == 0) {
            a = 10;
        } else {
            a = 20;
        }
}
```

字节码

```
 		 0: iconst_0
         1: istore_1
         2: iload_1
         3: ifne          12
         6: bipush        10
         8: istore_1
         9: goto          15
        12: bipush        20
        14: istore_1
        15: return
```

参考：https://docs.oracle.com/javase/specs/jvms/se7/html/jvms-6.html#jvms-6.5.lcmp

### 5、循环指令控制

while 循环

```java
public static void main(String[] args) {
        int a = 0;
        while (a < 10) {
            a++;
        }
 }
```

字节码

```
 		 0: iconst_0
         1: istore_1
         2: iload_1
         3: bipush        10
         5: if_icmpge     14
         8: iinc          1, 1
        11: goto          2
        14: return

```

do while循环

```java
public static void main(String[] args) {
        int a = 0;
        do {
            a++;
        } while (a < 10);
}
```

字节码

```
		 0: iconst_0
         1: istore_1
         2: iinc          1, 1
         5: iload_1
         6: bipush        10
         8: if_icmplt     2
        11: return

```

for循环

```java
public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {

}
}
```

字节码

```
		 0: iconst_0
         1: istore_1
         2: iload_1
         3: bipush        10
         5: if_icmpge     14
         8: iinc          1, 1
        11: goto          2
        14: return

```

### 6、练习 分析 x=0

从字节码角度分析，下列代码的运行结果

```java
 public static void main(String[] args) {
        int i = 0;
        int x = 0;
        while (i < 10){
            x = x++;
            i++;
        }
        System.out.println(x);
 }
```

字节码

```
 		 0: iconst_0
         1: istore_1
         2: iconst_0
         3: istore_2
         4: iload_1
         5: bipush        10
         7: if_icmpge     21
        10: iload_2
        11: iinc          2, 1
        14: istore_2
        15: iinc          1, 1
        18: goto          4
        21: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
        24: iload_2
        25: invokevirtual #3                  // Method java/io/PrintStream.println:(I)V
        28: return

```

` 2: iconst_0`		`3: istore_2`

- 准备一个变量且赋值为0，放入 局部变量表 2号槽 位置，即现在 2号槽 x = 0

- x++：先 `iload_2`，再 `iinc  2, 1` 
  - `iload_2` 的结果就是把 局部变量表 2号槽 位置的数读入 操作数栈，所以此时 操作数栈 的元素值是 0
  -  `iinc  2, 1`  接下来再执行自增，自增的结果就是 局部变量表 中  2号槽 位置 x 的值 ＋1
- 但是自增完成后，又做了个赋值操作，就是把 操作数栈 中的 0，取出来，再覆盖掉 局部变量表 的 x，也就是第一次循环后，仍是0。

### 7、构造方法

构造方法如果进行细分，可分为

1. **< cinit >( )V**

```
   	static int i = 10;
       static {
           i = 20;
       }
       static {
           i = 30;
       }
   ```

上面代码的执行结果是：30

分析：其实 所有静态变量赋值操作、静态代码块的代码，最终会被合并成一个方法。

编译器 会按 从上至下 的顺序，收集所有 static 静态代码块和静态成员赋值 的代码，合并成一个特殊的方法 **< cinit >( )V**：

```
    		 0: bipush        10
            2: putstatic     #3                  // Field i:I
            5: bipush        20
            7: putstatic     #3                  // Field i:I
           10: bipush        30
           12: putstatic     #3                  // Field i:I
           15: return
   ```

`bipush        10` 拿到一个变量值为 10，放入操作数栈

`putstatic     #3` 调用 `putstatic` ，进行 static 变量的赋值

`#2` 到 常量池 中找到一个名字为：i 的变量

以此类推，可以看出，其实就是 从上到下，把这些代码手机后形成一个新的方法，而这个新的方法将来是在**类加载的初始化阶段被调用**。

即，**< cinit >( )V** 方法会在 **类加载的初始化阶段被调用**。

2. **< init >( )V**

```java
   public class Demo3_2 {
   
       private String a = "s1";
       {
           b = 20;
       }
       private int b = 10;
       {
           a = "s2";
       }
   
       public Demo3_2(String a, int b) {
           this.a = a;
           this.b = b;
       }
   
       public static void main(String[] args) {
           Demo3_2 str = new Demo3_2("s3",30);
           System.out.println(str.a);//s3
           System.out.println(str.b);//30
       }
   }
   ```

解析：

其实所谓的 对成员变量的赋值、初始化代码块、构造方法里的代码，最终也会被收集成一个方法，也就是说最终会把代码合并在一起，从字节码角度分析：

编译器会按 从上至下 的顺序，收集所有 { } 代码块和成员变量赋值的代码，形成新的构造方法，**但原始构造方法内的代码总是在新的构造方法的最后**

`Demo3_2 str = new Demo3_2("s3",30);` 调用构造方法，内部生成新的构造方法，从 `private String a = "s1";` 开始，最后执行到 ` this.a = a;`，把 `"s3"` 赋值给 `a=“s2"`，即覆盖，同理 `b=30`

对应的字节码

```shell
   		 0: aload_0
            1: invokespecial #1                  // Method java/lang/Object."<init>":()V
            4: aload_0
            5: ldc           #2                  // String s1
            7: putfield      #3                  // Field a:Ljava/lang/String;
           10: aload_0
           11: bipush        20
           13: putfield      #4                  // Field b:I
           16: aload_0
           17: bipush        10
           19: putfield      #4                  // Field b:I
           22: aload_0
           23: ldc           #5                  // String s2
           25: putfield      #3                  // Field a:Ljava/lang/String;
           28: aload_0
           29: aload_1
           30: putfield      #3                  // Field a:Ljava/lang/String;
           33: aload_0
           34: iload_2
           35: putfield      #4                  // Field b:I
           38: return
   
   ```

### 8、方法调用

看一下几种不同的方法调用对应的字节码指令

```java
public class Demo3_2 {

public Demo3_2(){   }

private void test1() {   }

private final void test2() {   }

public void test3() {   }

public static void test4() {   }

public static void main(String[] args) {
        Demo3_2 str = new Demo3_2();
        str.test1();
        str.test2();
        str.test3();
        str.test4();
        Demo3_2.test4();
    }
}
```

```shell
 		 0: new           #2                  // class com/alibaba/classloader/Demo3_2
         3: dup
         4: invokespecial #3                  // Method "<init>":()V
         7: astore_1
         8: aload_1
         9: invokespecial #4                  // Method test1:()V
        12: aload_1
        13: invokespecial #5                  // Method test2:()V
        16: aload_1
        17: invokevirtual #6                  // Method test3:()V
        20: aload_1
        21: pop
        22: invokestatic  #7                  // Method test4:()V
        25: invokestatic  #7                  // Method test4:()V
        28: return

```

分析：

- 可以看出，构造方法、私有方法、final方法调用的都是 `invokespecial`，静态绑定
- 如果是公共方法，调用的是 `invokevirtual`
- 如果是静态方法，调用的是 `invokestatic`，静态绑定
- 以上是 JVM 对调用不同方法使用了不同的字节码指令，而 `invokespecial `和 `invokestatic` 都是静态绑定，也就是在字节码指令生成时，就能找到是哪个类的哪个方法，构造方法肯定是能唯一确定的，包括私有方法、静态方法也是。但唯独 普通的 public 方法可能出现方法重写，所以在编译期间，也就是 `invokevirtual`在编译期间不能确定自己是 哪个类的哪个方法，也许是子类也许是父类，所以称为 动态绑定，需在运行时确定。
- 从性能上讲， `invokespecial `和 `invokestatic`  性能都相对高，因为属于静态绑定，运行时就直接找到 方法的执行地址了，而 `invokevirtual`需要查找多次才能确定方法的入口地址
- `new ` 使用 new 关键字去调用构造方法，调用构造方法时，首先使用 new 分配了一个对象在堆空间需要的内存，这里其实是分了两步，第一步分配内存，第二步，若分配成功，会把对象的引用放入操作数栈
- `dup`，把栈顶地址再复制一份（刚刚创建那个对象的引用）
- `invokespecial #3 // Method "<init>":()V` 把栈顶的对象引用调用构造方法，调用结束后清除该对象引用，所以需复制一份，一份是配合 `invokespecial` 进行构造方法的调用，
- `astore_1` 才是把 操作数栈 中的栈顶元素放入 局部变量表 中的 d 变量去
- `pop` 静态方法不需要对象调用，所以把对象的引用的 pop 掉，即出栈。即多了两条废弃的指令

![image-20211104111621414](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211104111629.png)

### 9、多态原理

```java
package com.alibaba.classloader;

import java.io.IOException;

/**
 * 演示多态原理 ,注意加上下面 JVM 参数，禁用 指针压缩
 * -XX:-UseCompressedOops -XX:-UseCompressedClassPointers
 */
public class Demo3_3 {

public static void test(Animal animal) {
        animal.eat();
        System.out.println(animal.toString());
    }

public static void main(String[] args) throws IOException {
        test(new Dog());
        test(new Cat());
        System.in.read();
    }
}

abstract class Animal{
    public abstract void eat();

@Override
    public String toString() {
        return "我是" + this.getClass().getSimpleName();
    }
}
class Dog extends Animal{

@Override
    public void eat() {
        System.out.println("啃骨头");
    }
}
class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("吃小鱼");
    }
}

/*
啃骨头
我是Dog
吃小鱼
我是Cat
*/
```

对应的虚拟机指令：`invokevirtual` ，多态调用

注意运行代码时，需加 `-XX:-UseCompressedOops -XX:-UseCompressedClassPointers`，这两个虚拟机参数的作用是禁用指针压缩，64位的虚拟机为了节省内存空间采用指针压缩技术，所以待会查看地址造成不方便，还需进行地址换算

- 运行代码

停在 `System.in.read()` 方法上。这时运行 jps 获取进程 ID

- 运行 HSDB（HotSpot  Debugger） 工具

进入 JDK 安装目录，执行以下代码：

```shell
  java -cp ./lib/sa-jdi.jar sun.jvm.hotspot.HSDB
  ```

能够看到虚拟机中底层的内存状态和内存地址

![image-20211104113834144](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211104113835.png)

![image-20211104144245713](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211104144247.png)

连接成功后，我们怎么在 Java 虚拟机中找到一个对象

![image-20211104144458170](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211104144459.png)

查看到对象在内存中的地址 全限定类名起别名，与SQL语句类似

![image-20211104145038482](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211104145039.png)

点击该内存地址，会显示该对象在内存中的实际表示

![image-20211104145300052](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211104145301.png)

收官，学不下了

### 10、异常处理

#### 1、catch

```java
 public static void main(String[] args) {
        int i = 0;
        try {
            i = 10;
        }catch (Exception e){
            i = 20;
        }
  }
```

```json
 		 0: iconst_0			// 一个变量值为0
         1: istore_1			// 为局部变量表1号槽位赋值
         2: bipush        10	// 准备 10 这个数
         4: istore_1			// 为局部变量表1号槽位赋值
         5: goto          12
         8: astore_2
         9: bipush        20
        11: istore_1
        12: return
        
	 Exception table:
         from    to  target type
             2     5     8   Class java/lang/Exception
             
     LocalVariableTable:
     Start  Length  Slot  Name   Signature
       9       3     2     e   Ljava/lang/Exception;
       0      13     0  args   [Ljava/lang/String;
       2      11     1     i   I

from    to 异常表，会检测 第2行到第5行 的虚拟机指令（含头不含尾）
target 如果检测出现异常，会先进行类型匹配，看看发生的异常与声明的异常是否一致type，如果出现异常就进入 第8行

8: astore_2：看局部变量表，2号位置是 e，也就是异常，即 Exception 也是变量，也是局部变量表中的一部分，即 8: astore_2 就是把异常对象的引用对象存入局部变量表2（e）号槽位

9: bipush   20 ：准备一个数 20
```

- 可以看到多出来一个 Exception table 的结构，[from ,to）是 前闭后开 的检测范围，一旦进入这个范围内的字节码执行出现异常，则通过 type 匹配异常类型，如果一致，进入 target 所指示行号
- 8行的字节码指令 astore_2 是将异常对象引用存入局部变量表的 slot 2 位置

#### 2、finally

```java
public static void main(String[] args) {
        int i = 0;
        try {
            i = 10;
        }catch (Exception e){
            i = 20;
        }finally {
            i = 30;
        }
 }
```

```java
	Code:
      stack=1, locals=4, args_size=1
         0: iconst_0
         1: istore_1			//把 0 --> i
             					// try ------------------------------
         2: bipush        10	// 准备一个常量 10					 |	
         4: istore_1			// 10 --> i							 |
         5: bipush        30	// 准备一个常量 30					 |
         7: istore_1			// 30 --> i							 |
         8: goto          27										 |
             					// return-----------------------------
        11: astore_2			// catch  Exception -----------------
        12: bipush        20	// 准备一个常量 20
        14: istore_1			// 20 --> i	
        15: bipush        30	// 准备一个常量 30
        17: istore_1			// 30 --> i	
        18: goto          27	// return-----------------------------
        						// catch any -----------------
        21: astore_3
        22: bipush        30
        24: istore_1
        25: aload_3
        26: athrow
        27: return
      Exception table:
         from    to  target type
             2     5    11   Class java/lang/Exception
             2     5    21   any
            11    15    21   any
     
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
           12       3     2     e   Ljava/lang/Exception;
            0      28     0  args   [Ljava/lang/String;
            2      26     1     i   I

```

**注意：**

- finally 中的代码被复制了3份，分别放入 try 流程，catch 流程 以及 catch 剩余的异常类型流程，这样就保证 finally 中的代码一定会被执行。
-  Exception table：监测 2-5 行指令，如果出现异常，就是进行匹配，看看是不是 `Exception` 类型异常，如果是，就进入 11 行
- 但是由于 `catch (Exception e)` 并不能捕获所有异常，也许会抛出一个 Exception 父类的异常，比如 `Throwable` 或 `error` ，而 `finally` 又要求 其内部的代码总会被执行，即使 catch 捕获不到的，`finally` 也要执行，所以可以看到 局部变量表 中多了两项
  - `2     5    21   any`  监测 2-5 有没有其它类型异常
  - `11    15    21   any` 监测 11-15 行有没有其它类型异常，也就是监测 catch 块
  - 比如出现其它类型异常，会进入 21 行指令，
- `25: aload_3` 找到 3 号槽位（无名），把 异常对象的引用 加载到 操作数栈，然后用 ` athrow` 抛出
- 综上所述，代码一共有3个分支，而 finally 中的代码会被复制到这3个分支，确保一定被执行
  - try 分支
  - catch 分支
  - catch 分支未捕获到的异常分支

### 11、练习-finally 面试题

**finally 出现 return**

```java
public static void main(String[] args) {
        int result = test();
        System.out.println(result);	//20
    }
    public static int test(){
        try {
            return 10;
        }finally {
            return 20;
        }
}
```

![image-20211104160406665](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211104160407.png)

- 由于 finally 中的 ireturn 被插入了所有可能的流程，因此返回结果肯定以 finally 的为准
- 至于字节码中的 第2行，似乎没啥用，留个伏笔，看面试题2
- 跟上个例子中的 finally 相比，发现没有了 athrow，这说明什么？如果在 finally 中出现了 return，会吞掉异常，危险操作，且看下面例子
- ![image-20211104161118361](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211104161119.png)

### 12、练习-finally 面试题2

```java
 public static void main(String[] args) {
        int result = test();
        System.out.println(result);//10
    }
    public static int test(){
        int i = 10;
        try {
            return i;
        }finally {
            i = 20;
        }
 }
```

![image-20211104161312092](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211104161313.png)

- `4：istore_1` ：将 操作数栈 栈顶元素 存入 局部变量表 slot 1号 位置，slot 1 是无名字的，目的是为了固定返回值。
- `8：iload_1` ：将 slot 1 的值再次载入 操作数栈，然后 `9：ireturn` 返回
- `10：astore_2` 异常对象信息

### 13、synchronized

```java
public static void main(String[] args) {
       Object lock = new Object();
       synchronized (lock){
           System.out.println("ok");
       }
}
```

![image-20211104174016686](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211104174018.png)

分析：

synchronized 代码块，其实就是对一个对象进行 加锁 操作，那么它是如何保障：如果 synchronized 代码块中出现问题，那它对对象的正确解锁操作，也就是 加锁、解锁 是成对出现的。如果加了锁，将来出现问题，若没有正确解锁，那这个对象就没有其它线程可以访问了。所以下面从字节码角度分析加锁解锁的成对出现

- `3：dup`：把 new 出来的对象的引用复制一份，new对象会把对象的引用地址放入操作数栈，复制一份是为了用两次，第一次是为了消耗栈顶的对象引用
- ` 4: invokespecial #1` 执行构造方法
- ` 9: dup` 把对象加载到操作数栈后再复制一份，一份是给 `monitorenter` 一份是给 `monitorexit`，分别对应加锁指令和解锁指令
- `20: aload_2` 把加锁的对象加载的操作数栈，因为加锁解锁的对象都得是同一，通过 `monitorexit` 进行解锁

根据 Exception table，发现，不管方法正常执行还是中间出现异常，JVM指令总会再进入 25 行，加载 暂存的 lock 对象的引用，配合 `monitorexit` 进行解锁操作

**注意：** 方法级别的 synchronized 不会在字节码指令中有所体现

## 3、编译期处理

所谓的 `语法糖` ，其实就是指 Java 编译器把 `*.java` 源码编译为 `*.class` 字节码的过程中，自动生成和转换的一些代码，主要是为了减轻程序员负担，算是 Java 编译器给我们的一个额外福利

注意，以下代码的分析，借助了 javap 工具，idea 的反编译功能，idea 插件 jclasslib 等工具。另外，编译器转换的结果直接就是 class 字节码，只是为了便于阅读，给出了 几乎等价 的 java 源码方式，并不是编译器还会转换出中间的 java 源码，切记。

#### 1、默认构造器

```java
public class Candy1{

}
```

编译成 class 后的代码

```java
public class Candy1{
	// 这个无参构造是编译器帮助我们加上的
	public Candy1(){ 
		super();//即调用父类 Object 的无参构造方法，即调用 java/lang/Object."<init>":()V
	}
}
```

#### 2、自动拆装箱

![image-20211104223728610](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211104223729.png)

## 4、类加载阶段

### 4.1 加载

**概述：**

我们都知道，Java 编译成字节码后，要运行需要通过 类加载器，将类的字节码载入方法区中，内部采用 C++ 的 instanceKlass 描述 java 类，它的重要 fifield（域） 有：

- _java_mirror 即 java 的类镜像，例如对 String 来说，就是 String.class，作用是把 klass 暴

露给 java 使用

- _super 即父类
- _fifields 即成员变量
- _methods 即方法
- _constants 即常量池
- _class_loader 即类加载器
- _vtable 虚方法表
- _itable 接口方法表

如果这个类还有 父类 没有加载，先加载父类；

加载和链接可能是交替执行的

- instanceKlass 这样的【元数据】是存储在方法区（1.8 后的元空间内），但 _java_mirror是存储在堆中
- 可以通过前面介绍的 HSDB 工具查看

![image-20211109132934317](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211109132942.png)

### 4.2 链接

1. 验证

2. 准备

**准备**

为 static 变量分配空间，设置默认值

- static 变量在 JDK 7 之前存储于 instanceKlass 末尾，从 JDK 7 开始，存储于 _java_mirror 末尾

- static 变量分配空间和赋值是两个步骤，分配空间在准备阶段完成，赋值在初始化阶段完成

- 如果 static 变量是 final 的基本类型，以及字符串常量，那么编译阶段值就确定了，赋值在准备阶段完成

- 如果 static 变量是 final 的，但属于引用类型，即 new 对象，那么赋值也会在初始化阶段完成

### 4.3 初始化

`< cinit >()V` 方法

初始化即调用 `< cinit >()V` 方法，虚拟机会保证这个类的 【构造方法】的线程安全

**发生的时机**

1. 会导致 类初始化 的情况
   - main 方法所在的类，总会被首先初始化
   - 首次访问这个类的 静态变量 或 静态方法 时
   - 子类初始化，如果父类还未初始化，会引发
   - 子类访问父类的静态变量，只会触发父类的初始化
   - Class.forName
   - new 会导致初始化
2. 不会导致 类初始化 的情况
   - 访问 类的 static final 静态变量（基本类型和字符型）不会触发初始化
   - 类对象.class  不会触发初始化
   - 创建该类的数组不会触发初始化
   - 类加载的 loadClass 方法
   - Class.forName 的参数2 为 false 时

```java
package com.alibaba.classloader;

public class A {
    static int a = 0;
    static {
        System.out.println("a init");
    }
}
class B extends A {
    final static double b = 5.0;
    static boolean c = false;
    static {
        System.out.println("b init");
    }
}

```

```java
package com.alibaba.classloader;

public class Load1 {

static {
        System.out.println("main init");
    }
    public static void main(String[] args) throws ClassNotFoundException {
        // 1. 静态常量（基本类型和字符串）不会触发初始化
//         System.out.println(B.b);
        // 2. 类对象.class 不会触发初始化
//         System.out.println(B.class);
        // 3. 创建该类的数组不会触发初始化
        // System.out.println(new B[0]);
        // 4. 不会初始化类 B，但会加载 B、A
        // ClassLoader cl = Thread.currentThread().getContextClassLoader();
        // cl.loadClass("cn.itcast.jvm.t3.B");
        // 5. 不会初始化类 B，但会加载 B、A
        // ClassLoader c2 = Thread.currentThread().getContextClassLoader();
        // Class.forName("com.alibaba.classloader.B", false, c2);

// 1. 首次访问这个类的静态变量或静态方法时
        // System.out.println(A.a);
        // 2. 子类初始化，如果父类还没初始化，会引发
        // System.out.println(B.c);
        // 3. 子类访问父类静态变量，只触发父类初始化
        // System.out.println(B.a);
        // 4. 会初始化类 B，并先初始化类 A
        // Class.forName("com.alibaba.classloader.B");
    }
}

```

## 5、运行期优化

### 1、即时编译

查看每次创建对象 耗费的时长

```java
package com.alibaba.classloader;

public class JIT1 {
    public static void main(String[] args) {
        for (int i = 0; i < 200; i++) {
            long start = System.nanoTime();
            for (int j = 0; j < 1000; j++) {
                new Object();
            }
            long end = System.nanoTime();
            System.out.printf("%d\t%d\n",i,(end - start));
        }
    }
}
```

```
0	82300
1	56400
2	50600
3	49400
32	51900

74	25900
75	24100
124	20200
125	16500
126	17800
127	18700
128	121000

150	800
197	900
198	900
199	800
```

原因是什么？

在运行期间，JVM会对代码进行一定优化

JVM 将执行状态分成了 5 个层次

- 0层，解释执行（Interpreter），字节码被加载到虚拟机后，靠解释器解释执行，解释器会把字节码转为真正的字节码，CPU才可以识别并执行
- 1层，使用 C1 即时编译器编译执行（不带 profiling），当字节码被反复调用，到达一定阈值后，JVM就会启用编译器对字节码进行编译执行，即从 0层 上升到 1层
- 2层，使用 C1 即时编译器编译执行（带基本的 profiling）
- 3层，使用 C1 即时编译器编译执行（带完全的 profiling）
- 4层，使用 C2 即时编译器编译执行

```
profiling 信息统计操作 是指在运行过程中收集一些程序执行状态的数据，例如【方法的调用次数】、【循环的回边次数】等
```

即时编译器【 JIT 】与解释器的区别

- 解释器是将字节码解释为机器码，下次即时遇到相同的字节码，仍会执行重复的解释
- JIT 是将一些字节码编译成机器码，并存入 Code Cache ，下次遇到相同的代码，直接执行，无需再编译
- 解释器是将字节码解释为针对所有平台都通用的机器码
- JIT 会根据平台类型，生成平台特定的机器码

C1 与 C2 的区别

- 优化程度不同
- C1 只做基本的优化，有 `profiling`
- C2 做一些更完全更彻底的优化

其实对于日常开发中，很多代码调用次数不是很频繁，编译本身也耗费时间，所以JVM采用对于占据大部分的不常用代码，我们无需耗费时间将其编译成机器码，而是采取解释执行的方法运行；另一方面，对于仅占据小部分的热点代码，我们则可以将其编译成机器码，以达到理想的运行速度。执行效率上简单比较一下  Interpreter < C1 < C2，总的目标是发现热点代码（hotspot名称的由来），优化之

刚才的一种优化手段称为 【逃逸分析】，发现新建的对象是否逃逸，分析 new Object() 对象会不会在循环外被调用，或会不会被其它方法所引用，发现不会，因为其只是循环内的局部变量，所以就采用了该优化手段。

可以使用 `-XX:-DoEscapeAnalysis`  关闭逃逸分析

```java
public static void main(String[] args) {
        for (int i = 0; i < 200; i++) {
            long start = System.nanoTime();
            for (int j = 0; j < 1000; j++) {
                new Object();
            }
            long end = System.nanoTime();
            System.out.printf("%d\t%d\n",i,(end - start));
        }
}
```

# 五、内存模型

## 1、Java 内存模型

Java Memory Model （ JMM ）

简单的说，JMM 定义了一套在多线程读写共享数据（成员变量、数组）时，对数据的 可见性、有序性和 原子性 的规则和保障。

### 1、原子性

参考 synchronized

### 2、可见性

下面的代码， main 主线程 对 run 变量的修改对于 t线程 不可见，导致了 t线程 无法停止：

```java
public class Demo4_1 {
    static boolean run = true;
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(()->{
            while (run){
                //...
            }
        });
        t.start();
        Thread.sleep(1000);
        run = false;
    }
}
```

为什么t线程无法停止呢？分析以下:

1. 初始状态，t线程 刚开始从主内存读取了 run 的值到工作内存

![image-20211110143038776](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211110143047.png)

2. 因为 t线程 要频繁从 主内存 中读取 run 的值，JIT即时编译器会将 run 的值缓存到自己的工作内存中的高速缓存中，减少对主存中 run 的访问，提高效率

![image-20211110143233729](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211110143235.png)

3.  Thread.sleep(1000) 1秒后，main线程修改了 run 的值，并同步至主存，而 t 是从自己的工作内存中的高速缓存中读取这个变量的值，结果永远是旧值

![image-20211110143429941](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211110143431.png)

**解决办法**

volatile （易变关键字）

它可以用来修饰成员变量和静态成员变量，它可以避免线程从自己的工作缓存中查找变量的值，必须到主存中获取它的值，线程操作 volatile 变量都是直接操作主存

```java
volatile static boolean run = true;
```

**小结：**

上述例子体现的就是 可见性，它保证的是**在多个线程之间，一个线程对 volatile 变量的修改对另一个线程可见，不能保证原子性，仅用在 一个写线程，多个读线程 的情况**

**注意：**

- synchronized 语句既可以保证代码块的原子性，也同时保证代码块内变量的可变性，缺点是 synchronized 是重量级操作，性能较低

### 3、有序性

![image-20211110151242364](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211110151243.png)

![image-20211110151305602](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211110151307.png)

**有序性理解**

JVM 会在不影响正确性的前提下，可以调整语句的执行顺序

```java
static int i; 
static int j;

// 在某个线程内执行如下赋值操作
i = ...;// 较为耗时的操作
j = ...;
```

可以看到，至于是先执行 i 还是 先执行 j ，对最终的结果不会产生影响。所以，上面代码真正执行

时，既可以是

```
i = ...; // 较为耗时的操作
j = ...;
```

也可以是

```java
j = ...; 
i = ...; // 较为耗时的操作
```

这种特性称之为『指令重排』，多线程下『指令重排』会影响正确性，例如著名的 double-checked locking 模式实现单例

```java
public final class Singleton {
    private Singleton() { }
    private static Singleton INSTANCE = null;
    public static Singleton getInstance(){
        // 实例还没创建，才会进入内部的 synchronized 代码块
        if (INSTANCE == null){
            synchronized (Singleton.class){
                // 也许有其它线程已经创建实例，所以再判断一次
                if (INSTANCE == null){
                    INSTANCE = new Singleton();
                }
            }
        }
        return INSTANCE;
    }
}
```

实现懒惰初始化，先看单例有无被创建，如果已经创建，则直接拿到并返回，但是为了实现懒惰初始化，也得考虑线程安全问题，假如多个线程并发调用 `getInstance()` 方法，就可能造成该单例对象被创建多次，最懒惰的做法是给 `getInstance()` 方法直接加 synchronized 关键字，但这样锁的力度太大，不管第一次调用还是最后一次调用，都会加锁，性能很低，而实际上只需要在第一次调用时，防止多线程创建多次对象需要加锁，而后续只要该对象被创建了，就并不需要加锁了

为什么需要第二次判断 `if (INSTANCE == null)` 呢？比如线程1来了，发现 对象还没被创建，这时进入同步代码块，锁住类对象，然后执行代码块中的代码，但如果 线程2 此时也来调用  `getInstance()` 方法，那么肯定会被挡在 synchronized 代码块之外，等 线程1 执行完，放开锁，线程2 才又进入 代码块，那么如果没有 第二次 判断 `if (INSTANCE == null)` 的话，线程2 还会再去 `INSTANCE = new Singleton();` 这就与 单例模式 不符合了，因为创建了两次对象

而如果没有 第一次判断 `if (INSTANCE == null)` ，与直接 加 synchronized 又没区别~

以上实现的特点是：

- 懒惰实例化
- 首次使用 `getInstance()` 才使用 synchronized 加锁，后续使用时无需加锁

但在多线程环境下，上面代码是有问题的，没有考虑 指令重排 问题， `INSTANCE = new Singleton();` 对应的字节码为：

```java
17: new           #3    // class com/alibaba/jmm/Singleton 
20: dup
21: invokespecial #4    // Method "<init>":()V
24: putstatic     #2    // Field INSTANCE:Lcom/alibaba/jmm/Singleton
```

`17: new`  为对象分配空间，结果是 把对象的引用放入操作数栈

`20: dup` 操作数栈 把该对象的引用复制一份，相当于现在 栈顶有两个对象的引用

`21: invokespecial`  第一个对象交给了 `invokespecial` 去调用构造方法

`24: putstatic` 第二个对象的引用交给了 `putstatic` ，为 `INSTANCE` 静态变量赋值

而问题就出现在 21、24 这两行指令，有可能发生 指令重排，也许 JVM 会优化为：先将 引用地址 赋值给  `INSTANCE`  变量后，再执行 构造方法，如果两个线程 t1,t2 按如下时间序列执行：

```java
时间1  t1  线程执行到 INSTANCE = new Singleton();
时间2  t1  线程分配空间，为Singleton对象生成了引用地址（17 处） 
时间3  t1  线程将引用地址赋值给 INSTANCE，这时 INSTANCE != null（24 处） 
时间4  t2  线程进入getInstance() 方法，发现 INSTANCE != null（synchronized块外），直接 返回 INSTANCE 
时间5  t1  线程执行Singleton的构造方法（21 处）
```

这时 t1 还未完全将构造方法执行完，如果在构造方法中要执行很多初始化操作，那么 t2 拿到的将是一个 未初始化完毕 的单例。因为最外层的 第一次判断 `if (INSTANCE == null)` 已经确定不为空，直接 return 了

**解决方法：**对 INSTANCE 使用 volatile 修饰即可，可以禁用 指令重排

### 4、happens-before

![image-20211110163347279](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211110163348.png)

![image-20211110163401920](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211110163403.png)

![image-20211110163415066](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211110163416.png)

![image-20211110163432774](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211110163434.png)

## 2、CAS 与 原子类

### 1、CAS

CAS 即 Compare and Swap ，它体现的是一种 乐观锁 的思想，也被称为：无锁并发，比如多个线程要对一个共享的整型变量执行 +1 操作：

```java
// 需要不断尝试
while(true) {
    int 旧值 = 共享变量 ; // 比如拿到了当前值 0
    int 结果 = 旧值 + 1; // 在旧值 0 的基础上增加 1，正确结果是 1
    
    /*
   		这时候如果别的线程把共享变量改成了 5，本线程的正确结果是 1，那就作废了
   		这时候 compareAndSwap 返回 false，重新尝试，直到：
   		      compareAndSwap 返回 true，表示本线程做修改的同时，别的线程没有干扰
    */
    if( compareAndSwap( 旧值，结果 ) ){
        // 成功，退出循环
    } 
}
```

之前谈过要保护一些 共享变量 的安全性，要使用 synchronized 加锁，而 CAS 根本不加锁

`compareAndSwap( 旧值，结果 )` 尝试把 结果 赋值给 共享变量，但是赋值的同时，会把 旧值 与 **当前**共享变量 的值作比较，因为有可能在写入结果时，其它线程可能把 共享变量 的结果改了，所以得拿 旧值 与 **当前**共享变量 的值作比较，如果相同，才能成功把 结果 赋值给 共享变量。如果不同，说明其它线程把 共享变量 改变了，如果 共享变量被改变了，说明 `compareAndSwap( 旧值，结果 )`这次尝试就失败了，此时就会返回 false，重新执行...

获取共享变量时，为了保证该变量的可见性，需要使用 volatile 修饰。结合 CAS 和 volatile 可以实现 无锁并发 ，适用于竞争不激烈、多核 CPU 的场景：

- 如果竞争激烈，可以想到重试必然频繁发生，反而会影响效率
- 因为 重试 操作是需要使用 CPU 时间的，不想 synchronized ，在等待的过程中，线程就 阻塞 了，也就是休眠了，必须等其它线程把 锁 放开，其它线程才能恢复运行，而 CAS 需要不断重试，所以需要利用 CPU 时间，所以如果 CPU 就一个，那么 CAS 也就无从谈起了，也就是其它线程在修改的时候，CAS 想重试也没时间可用
- 因为没有使用 synchronized ，所以线程不会陷入 阻塞，倘若 线程 一旦进入 阻塞状态，就会涉及到 线程上下文 切换，上下文切换 就会把当前线程的运行状态保存下来，然后再让其进入阻塞，所以等到该线程再次被唤醒，又得把 上次的运行状态进行恢复，这个是很耗时的，而 CAS 由于线程一直在跑，不会陷入阻塞，所以没有 线程上下文切换，所以在 低竞争 的环境下效率比 synchronized 高

### 2、乐观锁与悲观锁

- CAS 是基于乐观锁的思想：最乐观的估计，不怕别的线程来修改共享变量，就算改了也没关系，我吃亏点再重试呗。
- synchronized 是基于悲观锁的思想：最悲观的估计，得防着其它线程来修改共享变量，我上了锁你们都别想改，我改完了解锁，你们才有机会

### 3、原子操作类

JUC（ java.util,concurrent ）中提供了原子操作类，可以提供线程安全的操作，例如：AtomicInteger（原子整数类，能保证整数的自增自减的线程安全）、AtomicBoolean等，它们的底层就是采用 CAS 技术 + volatile 实现的

使用 AtomicInteger 改写之前的例子

```java
package com.alibaba.jmm;
import java.util.concurrent.atomic.AtomicInteger;

public class AtomicIntegerTest {

// 创建原子整数对象 并赋值 0
    private static AtomicInteger num = new AtomicInteger(0);

public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(()->{
            for (int i = 0; i < 5000; i++) {
                num.getAndIncrement();//相当于 num++
            }
        });

Thread t2 = new Thread(()->{
            for (int i = 0; i < 5000; i++) {
                num.getAndDecrement();//相当于 num--
            }
        });

t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(num);

}
}
```

### 4、synchronized 优化

Java HotSpot 虚拟机中，每个对象都有对象头（包括 class 指针 和 Mark Word）。Mark Word 平时存储这个对象的 哈希码、分代年龄（垃圾回收时从幸存区晋升到老年代），当加锁时，这些信息就根据情况被替换为 标记位、线程锁记录指针、重量级锁指针、线程 ID 等内容

#### 4.1 轻量级锁

如果一个对象虽然有多线程访问，但多线程访问的时间是错开的（也就是没有竞争），那么可以使用 轻量级锁 来优化。这就好比：

学生（线程 A）用课本占座，上了半节课，出门了（CPU时间到），回来一看，发现课本没变，说明没有竞争，继续上他的课。如果这期间有其它学生（线程 B）来了，会告知（线程A）有并发访问，线程 A 随即升级为重量级锁，进入重量级锁的流程。而重量级锁就不是那么用课本占座那么简单了，可以想象线程 A 走之前，把座位用一个铁栅栏围起来

假设有两个方法同步块，利用同一个对象加锁

```java
static Object obj = new Object();
public static void method1() {
    synchronized( obj ) { 
        // 同步块 A 
        method2(); 
    } 
}
public static void method2() { 
    synchronized( obj ) {
        // 同步块 B 
    }
}
```

每个线程的栈帧都会包含一个锁记录的结构，内部可以存储锁定对象的 Mark Word（ 8个字节）

![image-20211111164129576](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211111164130.png)

- 以上面代码为例，假如 线程1 调用 `method1()`  ，执行到 synchronized 同步代码块，那它怎么去 加锁 呢？首先要检查 对象锁的状态，若该对象的 Mark Word 的状态为 01，表示无锁，那么可以加锁，加锁时，首先要把 对象头的 Mark Word 赋值到 线程1 的 锁记录，赋值后就尝试加锁。那怎么才算加锁成功呢？就是得把 线程1的锁记录的地址赋值到 Mark Word 中，若成功赋值，那就表示加锁成功，如果失败，说明有竞争，那么就得走其他流程，比如锁膨胀到重量级锁。这就类似与 线程1 与 对象 之间做名片交换，把 Mark Word 的给 线程1，线程1把锁记录地址给 Mark Word，互相交换地址，将来解锁后再交换回来
- 加锁成功后，会更新 锁标记，从 `01( 无锁 )` 变成 `00( 轻量级锁 )` ，与此同时，Mark Word中就多了一个 线程1锁记录地址，这时说明 线程1 已经成功进入 同步块A 
- 接下来又要执行 `method2()` ，调用 `method2() ` 又进入一个新的 synchronized，进入后又要重复上面的操作
- 执行到第二次 `CAS 修改 Mark 为线程 1 锁记录地址` ，但这次修改就会失败了，为什么呢？因为 Mark Word 已经存储 线程1 的锁记录地址了，再修改就没必要了，此时就会发现修改失败了，此时就会执行 锁重入 ，但若发现是别的锁，那就说明有竞争，要进行锁升级。
- 发现是同个锁，所以获得锁的所有权，可以执行同步块B，执行完同步块B，会把线程1 中的锁记录地址里面存储的 Mark Word 弹出一个，因为刚刚存了两份。
- 回到同步块A，同步块A执行完，执行 解锁，把锁记录中存储的 Mark  Word 还给对象的 Mark Word，再把 Mark Word 的锁标记改成 `01` ，
- 再接下来 线程2 来了，又继续重复....因为时间错开，可以用 轻量级锁 保证线程安全问题

#### 4.2 锁膨胀

如果在尝试加 轻量级锁 的过程中， CAS 操作无法成功，这时一种情况就是有 其他线程为此对象加上了 轻量级锁，即有竞争，这时就需要进行 锁膨胀，将 轻量级锁 变为 重量级锁

```java
static Object obj = new Object(); 
public static void method1() {
	synchronized( obj ) {
		// 同步块
	}
}
```

![image-20211111171055217](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211111171056.png)

- 线程1 访问同步块，这时对象还是 无锁 的，因此把对象的 Mark Word 复制到 线程1 的锁记录，并且尝试用 CAS 去修改 Mark Word，把 对象Mark Word 设置为 线程1 的锁记录地址（交换名片），因为这时无其他线程，所以成功加锁了，Mark Word 的锁标记从 `01( 无锁 )` 变成  `00( 轻量级锁 )`，并且 Mark Word 存储的是 线程1 的锁记录地址
- 线程1 开始执行同步代码块，这时 线程2 来了，也要做与 线程1 类似的操作，也要尝试把 对象的 Mark Word 复制到 线程2 的锁记录地址，然后用 CAS 修改 Mark Word 为线程2 的锁记录地址，但显然该操作会失败，因为此时 Mark Word 里面存储的是 线程1锁记录地址，所以这时 线程2 此次 CAS 失败了，而且是别人上了锁导致的，此时就会 通过 CAS 修改 Mark Word 为重量级锁。
- 怎么从轻量级锁升级为重量级锁呢？首先把 锁标记从  `00( 轻量级锁 )` 变成  `10( 重量级锁 )`，升级完重量级锁后，线程2 就会到对象的 Monitor 去进行 阻塞，并且还会往 对象头里加 重量锁指针，加该指针的目的是为了将来 线程1 解锁时，能够根据该指针去唤醒阻塞中的线程
- 线程1继续执行完毕后，需要解锁，但此时解锁会失败，为什么呢？因为此时 对象头里 锁的状态已经不再是  `00( 轻量级锁 )` 了，已经是 `10( 重量级锁 )`了，而且 线程1 的锁记录地址 也不见了，已经变成 重量级锁指针了。但是失败了没事，因为只需按照 重量级锁 的方式去解锁就可以了
- 接下来 线程1 就会 释放重量级锁，所谓 释放重量级锁，就是根据 重量级锁指针 找到正在 阻塞 的线程，唤醒这些线程，让这些线程再竞争 重量级锁，当然会把对象的 Mark Word 信息还原回去，这就完成了 解锁 操作
- 解锁完成后，相当于 被阻塞的线程（线程2）也被唤醒了，唤醒后 就去竞争 重量级锁，然后用重量级锁的方式去加锁

#### 4.3 重量级锁-自旋

重量级锁竞争的时候，还可以使用 自旋 来进行优化，如果当前线程 自旋 成功（即这时候持锁线程已经退出了同步块，释放了锁），这时当前线程就可以避免阻塞。

- 自旋会占用 CPU 时间，单核 CPU 自旋 就是浪费，多喝 CPU 自旋才能发挥优势
- 好比等红灯时汽车是不是熄火，不熄火相当于自旋（等待时间短则划算），熄火了相当于阻塞（等待时间长则划算）
- Java 7 之后不能控制是否开启自旋功能

**自旋重试成功的情况**

![image-20211111181552993](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211111181554.png)

- 线程1 先访问 同步块，获取 Monitor，然后就会把 monitor 对应的重量级锁指针更新到 Mark Word 中，然后表示加锁成功，成功后开始执行同步块
- 这时 线程2 来了，线程2 也想加锁，也想去获取 monitor，但是已经被 线程1 加锁了，线程2 加不上了，但是这时不会马上进行 阻塞，因为进行阻塞就会把当前线程状态保存下来，将来被唤醒后又要进行恢复，比较耗时。
- 这时就采用了 自旋 优化。什么意思呢？就是说 线程2 先不阻塞，自旋重试一下，也就是再次试探 看看这个重量级锁 有没有被释放，重试几次后，线程1 执行完了，解锁了，解锁后，这个重量级锁的的状态就变成 `01`，这时重试几次后发现无锁了，就可以加锁成功了，这样就减少了线程上下文切换，从而提高效率。

**自旋重试失败的情况**

![image-20211111211522455](https://gitee.com/rabbli_zli/typora-img/raw/master/img/20211111211523.png)

- 重试多次后会放弃重试，然后陷入阻塞

#### 4.4 偏向锁

轻量锁在没有竞争时（就自己这个线程），每次重入仍需执行 CAS 操作。Java 6之后引入了 偏向锁 来做进一步优化：只有第一次使用 CAS 将 线程ID 设置到对象的 Mark Word 头，之后发现这个 线程ID 是自己的就表示没有竞争，不需要再重新 CAS

安生/jvm

简介

发行版

贡献者

近期动态

安生/jvm .gitee-modal { width: 500px !important; }

简介

发行版

贡献者

近期动态

搜索帮助

安生/jvm