# jvm-learn

**Repository Path**: wh543/jvm-learn

## Basic Information

- **Project Name**: jvm-learn
- **Description**: jvm学习笔记
- **Primary Language**: Java
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2021-02-02
- **Last Updated**: 2021-03-15

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# JVM 引言

## 编程语言
![](.README_images/88f035c7.png)

- 面向过程、面向对象、面向函数
- 静态类型、动态类型
- 编译执行、解释执行
- 有虚拟机、无虚拟机
- 有GC、无GC

Java是一种面向对象、静态类型、编译执行，有VM/GC和运行时、跨平台的高级语言



## 定义

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

## 优点

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

## JVM、JRE、JDK 之间的关系

![](.README_images/00027c40.png)



# 字节码与类加载

java语言规范以及JVM规范下载地址：https://docs.oracle.com/javase/specs/index.html



### 什么是字节码

​	Java bytecode 由单字节（byte）的指令组成，理论上最多支持256个操作码（opcode）。实际上Java只使用了200左右的操作码，还有一些操作码则保留给调试操作。
​	以下是编译后的class文件使用16进制查看的结果（使用javap -verbose命令查看的则是这些字节码的助记符Mnemonic）：
​    ![](.README_images/43e4b708.png)
​    根据指令的性质，主要分为四个大类：

1. 栈操作指令，包括与局部变量交互的指令
2. 程序流程控制指令
3. 对象操作指令，包括方法调用指令
4. 算术运算以及类型转换指令

生成字节码

```java
package com.wenhao.bytecode;

public class HelloByteCode {

    public static void main(String[] args) {
        HelloByteCode helloByteCode = new HelloByteCode();
    }
}
```
![](.README_images/0eda3644.png)

```
Compiled from "HelloByteCode.java"
public class com.wenhao.bytecode.HelloByteCode {
  public com.wenhao.bytecode.HelloByteCode();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public static void main(java.lang.String[]);
    Code:
       0: new           #2                  // class com/wenhao/bytecode/HelloByteCode
       3: dup
       4: invokespecial #3                  // Method "<init>":()V
       7: astore_1
       8: return
}

```

字节码中常用的load和store，指的是虚拟机栈加载本地变量中的数据，处理后存到本地变量的过程，其实就是入栈出栈的一个过程。
![](.README_images/dcf619cb.png)


通过-verbose打印详尽的信息。

java -p -verbose HelloByteCode

```c
Classfile /Users/liuwenhao/code/jvm-learn/target/classes/com/wenhao/bytecode/HelloByteCode.class
  Last modified 2021-2-2; size 495 bytes
  MD5 checksum dccb6a11373890b2fcbed372bac81d8c
  Compiled from "HelloByteCode.java"
public class com.wenhao.bytecode.HelloByteCode
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Methodref          #4.#20         // java/lang/Object."<init>":()V
   #2 = Class              #21            // com/wenhao/bytecode/HelloByteCode
   #3 = Methodref          #2.#20         // com/wenhao/bytecode/HelloByteCode."<init>":()V
   #4 = Class              #22            // java/lang/Object
   #5 = Utf8               <init>
   #6 = Utf8               ()V
   #7 = Utf8               Code
   #8 = Utf8               LineNumberTable
   #9 = Utf8               LocalVariableTable
  #10 = Utf8               this
  #11 = Utf8               Lcom/wenhao/bytecode/HelloByteCode;
  #12 = Utf8               main
  #13 = Utf8               ([Ljava/lang/String;)V
  #14 = Utf8               args
  #15 = Utf8               [Ljava/lang/String;
  #16 = Utf8               helloByteCode
  #17 = Utf8               MethodParameters
  #18 = Utf8               SourceFile
  #19 = Utf8               HelloByteCode.java
  #20 = NameAndType        #5:#6          // "<init>":()V
  #21 = Utf8               com/wenhao/bytecode/HelloByteCode
  #22 = Utf8               java/lang/Object
{
  public com.wenhao.bytecode.HelloByteCode();
    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/wenhao/bytecode/HelloByteCode;

  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=2, args_size=1
         0: new           #2                  // class com/wenhao/bytecode/HelloByteCode
         3: dup
         4: invokespecial #3                  // Method "<init>":()V
         7: astore_1
         8: return
      LineNumberTable:
        line 6: 0
        line 7: 8
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       9     0  args   [Ljava/lang/String;
            8       1     1 helloByteCode   Lcom/wenhao/bytecode/HelloByteCode;
    MethodParameters:
      Name                           Flags
      args
}
SourceFile: "HelloByteCode.java"
```

### 字节码的运行时结构

JVM是一台基于栈的计算机器。每个线程都有一个独属于自己的线程（JVM stack），用于存储栈帧（Frame）。每次方法调用，JVM都会自动创建一个栈帧。栈帧由**操作数栈**（Operant Stack）、**局部变量**表（Local Variables），**数组**以及一个**指向运行时常量池的引用（A reference to the run-time constant pool）**、**方法返回地址**（Return Address）组成。

局部变量表：存放方法中定义的局部变量以及方法的参数。局部变量表中的变量不可直接使用，如需要使用的话，必须通过相关指令将其加载至操作数栈中作为操作数使用。

操作数栈：以压栈和出栈的方式存储操作数

动态链接：每个栈帧都包含一个指向运行时常量池中该栈帧所属方法的引用，持有这个引用时为了支持调用过程中的动态链接（Dynamic Linking）

​	1.静态解析：类加载的时候，符号引用就转化成直接引用。

​	2.动态连接：运行期间转化为直接引用。

方法返回地址：当一个方法开始执行后，只有两种方式可以退出，一种是遇到方法返回的字节码指令；一种是遇到异常，并且这个异常没有在方法内得到处理。



四则运行的例子

```java
package com.wenhao.bytecode;

/**
 * 移动平均数
 */
public class MovingAverage {

    private int count = 0;
    private double sum = 0.0D;

    public void submit(double value) {
        this.count++;
        this.sum += value;
    }

    public double getAvg() {
        if (0 == this.count) {
            return sum;
        }
        return this.sum / this.count;
    }
}

```





```c++
Classfile /Users/liuwenhao/code/jvm-learn/target/classes/com/wenhao/bytecode/MovingAverage.class
  Last modified 2021-2-2; size 657 bytes
  MD5 checksum 7fb5be36412f5afb967e51c9691a13a8
  Compiled from "MovingAverage.java"
public class com.wenhao.bytecode.MovingAverage
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Methodref          #5.#26         // java/lang/Object."<init>":()V
   #2 = Fieldref           #4.#27         // com/wenhao/bytecode/MovingAverage.count:I
   #3 = Fieldref           #4.#28         // com/wenhao/bytecode/MovingAverage.sum:D
   #4 = Class              #29            // com/wenhao/bytecode/MovingAverage
   #5 = Class              #30            // java/lang/Object
   #6 = Utf8               count
   #7 = Utf8               I
   #8 = Utf8               sum
   #9 = Utf8               D
  #10 = Utf8               <init>
  #11 = Utf8               ()V
  #12 = Utf8               Code
  #13 = Utf8               LineNumberTable
  #14 = Utf8               LocalVariableTable
  #15 = Utf8               this
  #16 = Utf8               Lcom/wenhao/bytecode/MovingAverage;
  #17 = Utf8               submit
  #18 = Utf8               (D)V
  #19 = Utf8               value
  #20 = Utf8               MethodParameters
  #21 = Utf8               getAvg
  #22 = Utf8               ()D
  #23 = Utf8               StackMapTable
  #24 = Utf8               SourceFile
  #25 = Utf8               MovingAverage.java
  #26 = NameAndType        #10:#11        // "<init>":()V
  #27 = NameAndType        #6:#7          // count:I
  #28 = NameAndType        #8:#9          // sum:D
  #29 = Utf8               com/wenhao/bytecode/MovingAverage
  #30 = Utf8               java/lang/Object
{
  public com.wenhao.bytecode.MovingAverage();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=3, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
         4: aload_0
         5: iconst_0
         6: putfield      #2                  // Field count:I
         9: aload_0
        10: dconst_0
        11: putfield      #3                  // Field sum:D
        14: return
      LineNumberTable:
        line 6: 0
        line 8: 4
        line 9: 9
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      15     0  this   Lcom/wenhao/bytecode/MovingAverage;

  public void submit(double);
    descriptor: (D)V
    flags: ACC_PUBLIC
    Code:
      stack=5, locals=3, args_size=2
         0: aload_0 
         1: dup
         2: getfield      #2                  // Field count:I (获取count变量的值，并压入操作数栈)
         5: iconst_1 // 将int类型常量1（对应LocalVariableTable.Slot=1这个槽位）压入【操作数栈】
         6: iadd     // 将栈顶元素弹出栈，执行int类型的加法，结果入栈
         7: putfield      #2                  // Field count:I 给count赋予add后的值
        10: aload_0
        11: dup
        12: getfield      #3                  // Field sum:D
        15: dload_1 // 从【局部变量1】中装载double类型值入栈
        16: dadd
        17: putfield      #3                  // Field sum:D
        20: return
      LineNumberTable:
        line 12: 0
        line 13: 10
        line 14: 20
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      21     0  this   Lcom/wenhao/bytecode/MovingAverage;
            0      21     1 value   D
    MethodParameters:
      Name                           Flags
      value

  public double getAvg();
    descriptor: ()D
    flags: ACC_PUBLIC
    Code:
      stack=4, locals=1, args_size=1
         0: iconst_0
         1: aload_0
         2: getfield      #2                  // Field count:I
         5: if_icmpne     13 //i（int）cmp（compare）ne(not equal) 如果符合条件则跳到 13: aload_0 
         8: aload_0
         9: getfield      #3                  // Field sum:D
        12: dreturn
        13: aload_0
        14: getfield      #3                  // Field sum:D
        17: aload_0
        18: getfield      #2                  // Field count:I
        21: i2d // int 转 double
        22: ddiv
        23: dreturn
      LineNumberTable:
        line 17: 0
        line 18: 8
        line 20: 13
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      24     0  this   Lcom/wenhao/bytecode/MovingAverage;
      StackMapTable: number_of_entries = 1
        frame_type = 13 /* same */
}
SourceFile: "MovingAverage.java"

```



```java
package com.wenhao.bytecode;

public class LocalVariableTest {
    public static void main(String[] args) {
        MovingAverage ma = new MovingAverage();
        int num1 = 5;
        int num2 = 6;
        ma.submit(num1);
        ma.submit(num2);
        double avg = ma.getAvg();
    }
}

```



```c++
Classfile /Users/liuwenhao/code/jvm-learn/target/classes/com/wenhao/bytecode/LocalVariableTest.class
  Last modified 2021-2-2; size 725 bytes
  MD5 checksum ae61b08f77b845dbf98bae3710975045
  Compiled from "LocalVariableTest.java"
public class com.wenhao.bytecode.LocalVariableTest
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Methodref          #7.#29         // java/lang/Object."<init>":()V
   #2 = Class              #30            // com/wenhao/bytecode/MovingAverage
   #3 = Methodref          #2.#29         // com/wenhao/bytecode/MovingAverage."<init>":()V
   #4 = Methodref          #2.#31         // com/wenhao/bytecode/MovingAverage.submit:(D)V
   #5 = Methodref          #2.#32         // com/wenhao/bytecode/MovingAverage.getAvg:()D
   #6 = Class              #33            // com/wenhao/bytecode/LocalVariableTest
   #7 = Class              #34            // java/lang/Object
   #8 = Utf8               <init>
   #9 = Utf8               ()V
  #10 = Utf8               Code
  #11 = Utf8               LineNumberTable
  #12 = Utf8               LocalVariableTable
  #13 = Utf8               this
  #14 = Utf8               Lcom/wenhao/bytecode/LocalVariableTest;
  #15 = Utf8               main
  #16 = Utf8               ([Ljava/lang/String;)V
  #17 = Utf8               args
  #18 = Utf8               [Ljava/lang/String;
  #19 = Utf8               ma
  #20 = Utf8               Lcom/wenhao/bytecode/MovingAverage;
  #21 = Utf8               num1
  #22 = Utf8               I
  #23 = Utf8               num2
  #24 = Utf8               avg
  #25 = Utf8               D
  #26 = Utf8               MethodParameters
  #27 = Utf8               SourceFile
  #28 = Utf8               LocalVariableTest.java
  #29 = NameAndType        #8:#9          // "<init>":()V
  #30 = Utf8               com/wenhao/bytecode/MovingAverage
  #31 = NameAndType        #35:#36        // submit:(D)V
  #32 = NameAndType        #37:#38        // getAvg:()D
  #33 = Utf8               com/wenhao/bytecode/LocalVariableTest
  #34 = Utf8               java/lang/Object
  #35 = Utf8               submit
  #36 = Utf8               (D)V
  #37 = Utf8               getAvg
  #38 = Utf8               ()D
{
  public com.wenhao.bytecode.LocalVariableTest();
    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/wenhao/bytecode/LocalVariableTest;

  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=3, locals=6, args_size=1
         0: new           #2                  // class com/wenhao/bytecode/MovingAverage
         3: dup
         4: invokespecial #3                  // Method com/wenhao/bytecode/MovingAverage."<init>":()V
         7: astore_1 
         8: iconst_5 // 将int类型的常量5压入【操作数栈】
         9: istore_2 // 将int类型的值存入【槽位为2的局部变量，也就是num1】
        10: bipush        6 // 将int类型的常量6压入【操作数栈】
        12: istore_3 // 将int类型的值存入【槽位为3的局部变量，也就是num2】
        13: aload_1 
        14: iload_2
        15: i2d
        16: invokevirtual #4                  // Method com/wenhao/bytecode/MovingAverage.submit:(D)V
        19: aload_1
        20: iload_3
        21: i2d
        22: invokevirtual #4                  // Method com/wenhao/bytecode/MovingAverage.submit:(D)V
        25: aload_1
        26: invokevirtual #5                  // Method com/wenhao/bytecode/MovingAverage.getAvg:()D
        29: dstore        4
        31: return
      LineNumberTable:
        line 5: 0
        line 6: 8
        line 7: 10
        line 8: 13
        line 9: 19
        line 10: 25
        line 11: 31
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      32     0  args   [Ljava/lang/String;
            8      24     1    ma   Lcom/wenhao/bytecode/MovingAverage;
           10      22     2  num1   I
           13      19     3  num2   I
           31       1     4   avg   D
    MethodParameters:
      Name                           Flags
      args
}
SourceFile: "LocalVariableTest.java"

```



### 算数操作与类型转换

|        | add(+) | Sub(-) | Mult(*) | divide(/) | remainder(%) | negate(-()) |
| ------ | ------ | ------ | ------- | --------- | ------------ | ----------- |
| int    | iadd   | isub   | imult   | idiv      | irem         | ineg        |
| long   | ladd   | lsub   | lmult   | ldiv      | lrem         | lneg        |
| float  | fadd   | fsub   | fmult   | fdiv      | frem         | fneg        |
| Double | dadd   | dsub   | dmult   | ddiv      | drem         | dneg        |

|        | int  | long | float | double | byte | char | short |
| ------ | ---- | ---- | ----- | ------ | ---- | ---- | ----- |
| int    | -    | i2l  | i2f   | i2d    | i2b  | i2c  | i2s   |
| long   | l2i  | -    | l2f   | l2d    | -    | -    | -     |
| float  | f2i  | f2l  | -     | f2d    | -    | -    | -     |
| double | d2i  | d2l  | d2f   | -      | -    | -    | -     |

一个完整的循环控制

```
package com.wenhao.bytecode;

public class ForLoopTest {
    private static int[] numbers = {1, 6, 8};
    public static void main(String[] args) {
        MovingAverage movingAverage = new MovingAverage();
        for (int number : numbers) {
            movingAverage.submit(number);
        }
        double avg = movingAverage.getAvg();
    }
}

```



```c
Classfile /Users/liuwenhao/code/jvm-learn/target/classes/com/wenhao/bytecode/ForLoopTest.class
  Last modified 2021-2-2; size 873 bytes
  MD5 checksum 7c7aef5476c1df992aacf86952b9e4b9
  Compiled from "ForLoopTest.java"
public class com.wenhao.bytecode.ForLoopTest
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Methodref          #8.#36         // java/lang/Object."<init>":()V
   #2 = Class              #37            // com/wenhao/bytecode/MovingAverage
   #3 = Methodref          #2.#36         // com/wenhao/bytecode/MovingAverage."<init>":()V
   #4 = Fieldref           #7.#38         // com/wenhao/bytecode/ForLoopTest.numbers:[I
   #5 = Methodref          #2.#39         // com/wenhao/bytecode/MovingAverage.submit:(D)V
   #6 = Methodref          #2.#40         // com/wenhao/bytecode/MovingAverage.getAvg:()D
   #7 = Class              #41            // com/wenhao/bytecode/ForLoopTest
   #8 = Class              #42            // java/lang/Object
   #9 = Utf8               numbers
  #10 = Utf8               [I
  #11 = Utf8               <init>
  #12 = Utf8               ()V
  #13 = Utf8               Code
  #14 = Utf8               LineNumberTable
  #15 = Utf8               LocalVariableTable
  #16 = Utf8               this
  #17 = Utf8               Lcom/wenhao/bytecode/ForLoopTest;
  #18 = Utf8               main
  #19 = Utf8               ([Ljava/lang/String;)V
  #20 = Utf8               number
  #21 = Utf8               I
  #22 = Utf8               args
  #23 = Utf8               [Ljava/lang/String;
  #24 = Utf8               movingAverage
  #25 = Utf8               Lcom/wenhao/bytecode/MovingAverage;
  #26 = Utf8               avg
  #27 = Utf8               D
  #28 = Utf8               StackMapTable
  #29 = Class              #23            // "[Ljava/lang/String;"
  #30 = Class              #37            // com/wenhao/bytecode/MovingAverage
  #31 = Class              #10            // "[I"
  #32 = Utf8               MethodParameters
  #33 = Utf8               <clinit>
  #34 = Utf8               SourceFile
  #35 = Utf8               ForLoopTest.java
  #36 = NameAndType        #11:#12        // "<init>":()V
  #37 = Utf8               com/wenhao/bytecode/MovingAverage
  #38 = NameAndType        #9:#10         // numbers:[I
  #39 = NameAndType        #43:#44        // submit:(D)V
  #40 = NameAndType        #45:#46        // getAvg:()D
  #41 = Utf8               com/wenhao/bytecode/ForLoopTest
  #42 = Utf8               java/lang/Object
  #43 = Utf8               submit
  #44 = Utf8               (D)V
  #45 = Utf8               getAvg
  #46 = Utf8               ()D
{
  public com.wenhao.bytecode.ForLoopTest();
    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/wenhao/bytecode/ForLoopTest;

  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=3, locals=6, args_size=1
         0: new           #2                  // class com/wenhao/bytecode/MovingAverage
         3: dup
         4: invokespecial #3                  // Method com/wenhao/bytecode/MovingAverage."<init>":()V
         7: astore_1
         8: getstatic     #4                  // Field numbers:[I
        11: astore_2
        12: aload_2
        13: arraylength
        14: istore_3
        15: iconst_0
        16: istore        4
        18: iload         4
        20: iload_3
        21: if_icmpge     43
        24: aload_2
        25: iload         4
        27: iaload
        28: istore        5
        30: aload_1
        31: iload         5
        33: i2d
        34: invokevirtual #5                  // Method com/wenhao/bytecode/MovingAverage.submit:(D)V
        37: iinc          4, 1
        40: goto          18
        43: aload_1
        44: invokevirtual #6                  // Method com/wenhao/bytecode/MovingAverage.getAvg:()D
        47: dstore_2
        48: return
      LineNumberTable:
        line 6: 0
        line 7: 8
        line 8: 30
        line 7: 37
        line 10: 43
        line 11: 48
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
           30       7     5 number   I
            0      49     0  args   [Ljava/lang/String;
            8      41     1 movingAverage   Lcom/wenhao/bytecode/MovingAverage;
           48       1     2   avg   D
      StackMapTable: number_of_entries = 2
        frame_type = 255 /* full_frame */
          offset_delta = 18
          locals = [ class "[Ljava/lang/String;", class com/wenhao/bytecode/MovingAverage, class "[I", int, int ]
          stack = []
        frame_type = 248 /* chop */
          offset_delta = 24
    MethodParameters:
      Name                           Flags
      args

  static {};
    descriptor: ()V
    flags: ACC_STATIC
    Code:
      stack=4, locals=0, args_size=0
         0: iconst_3
         1: newarray       int
         3: dup
         4: iconst_0
         5: iconst_1
         6: iastore
         7: dup
         8: iconst_1
         9: bipush        6
        11: iastore
        12: dup
        13: iconst_2
        14: bipush        8
        16: iastore
        17: putstatic     #4                  // Field numbers:[I
        20: return
      LineNumberTable:
        line 4: 0
}
SourceFile: "ForLoopTest.java"
```

### 方法调用的指令

invokestatic，顾名思义，这个指令用于调用某个类的静态方法，这是方法调用指令中最快的一个。

invokespecial，用来调用构造函数，但也可以用于调用同一个类的private方法，以及可见的超类方法。

invokevitual，如果是具体类型的目标对象，invokevirtual用于调用公共，受保护和package级的私有方法。

invokeinterface，当通过接口引用来调用方法时，将会编译为invokeinterface指令。

invkedynamic，JDK7新增的指令，是实现“动态类型语言”（Dynamically Typed Language）支持儿进行的升级改进，同时也是JDK8之后支持lambda表达式的实现基础。



# JVM 类加载器

## 类的生命周期

1. 加载（Loading）：查找和导入Class文件
   1. 通过一个类的全限定名获取定义此类的二进制字节流
   2. 将这个字节流所代表的静态存储结构化为方法区的运行时数据结构
   3. 在java堆中生成一个代表这个类的java.lang.Class对象，作为对方法区中这些数据的访问入口
2. 连接：将已经读入内存的类的二进制数据合并到JVM运行环境中。
    1. 验证（Verification）：主要包括
       - 类文件结构检查：按照JVM规范规定的类文件结果进行验证；
       - 元数据验证：对字节码描述对信息进行语义分析，保证其符合Java语言规范要求；
       - 字节码验证：通过对数据流和控制流进行分析，确保程序语义是合法和符合逻辑。这里主要对方法体进行校验。
       - 符号引用验证：对类自身以外的信息，也就是常量池中的各种符号引用，进行匹配校验。
    2. 准备（Perparation）：为类的静态变量分配内存，并将其初始化为默认值
    3. 解析（Resolution）：把常量池中的符号引用解析为直接引用（直接指向目标的指针、相对偏移量、或者能间接定位到目标的句柄，是和虚拟机实现相关），主要针对：类、接口、字段、类方法、接口方法、方法类型、方法句柄、调用限定符
3. 初始化（Initializtion）：类的静态变量赋值、或者说是执行类构造器（不是实例构造器）<clinit>方法的过程
    1. 如果类还没加载和连接，就先加载和连接
    2. 如果类存在父类，且父类还没初始化，就先初始化父类
    3. 如果类中存在初始化语句，就执行执行这些初始化
    4. 如果是接口的话
        - 初始化一个类的时候，并不会先初始化实现的接口
        - 初始化一个接口时，并不会初始化它的父接口
        - 只有当程序首次使用接口里面的变量或者时调用接口方法的时候，才会导致接口初始化
    5. 调用Classloader类的loadClass方法来装载一个类，并不会初始化这个类，因为这不是对类的主动使用。
4. 使用（Using）
5. 卸载（Unloading）
    ![](.README_images/8f8d4b19.png)

## 类的加载时机

Java程序对类的使用方式分为：主动使用和被动使用，JVM必须在每个类或接口“首次主动使用”时才初始化它们；被动使用类不会导致类的初始化，主动使用的情况：


1. 当虚拟机启动时，初始化用户指定的主类，就是启动执行的main方法所在的类；
2. 当遇到用以新建目标类实例的new指令时，初始化new指令的目标类，就是new一个类的时候要初始化；
3. 当遇到调用静态方法的指令时，初始化该静态方法所在的类；
4. 当遇到访问静态字段的指令时，初始化该静态字段所在的类；
5. 子类的初始化会触发父类的初始化
6. 如果一个接口定义了default方法，那么直接实现或者间接实现该接口的类的初始化，会触发该接口的初始化；
7. 使用反射API对某个类进行反射调用时，初始化这个类，其实跟前面一样，反射调用要么时已经有实例了，要么时静态方法，都需要初始化；
8. 当初次调用MethodHandle实例时，初始化该MethodHandle指向的方法所在的类。



不会初始化（可能会加载）

1. 通过子类引用父类的静态字段，只会触发父类的初始化，而不会触发子类的初始化。
2. 定义对象数组，不会触发该类的初始化。
3. 常量在编译期间会存入调用类的常量池中，本质上并没有直接引用定义常量的类，不会触发定义常量所在的类。(public `final` static String msg = "msg")
4. 通过类名获取Class对象，不会触发类的初始化，Hello.class不会让Hello类初始化。
5. 通过Class.forName加载指定类时，如果指定参数initialize为false时，也不会触发类初始化，其实这个参数时告诉虚拟机，是否要对类进行初始化。Class.forName("jvm.Hello")默认会加载Hello类。
6. 通过ClassLoader默认的loadClass方法，也不会触发初始化动作（加载了，但是不会初始化）。



## 类装载器ClassLoader

在装载（Load）阶段，其中的第一步：通过类的全限定名获取其定义的二进制字节流，需要借助类装载器完成，顾名思义，就是用来装载Class文件的。

### ClassLoader分类

- Bootstrap ClassLoader 负责加载$JAVA_HOME中jre/lib/rt.jar里所有class或Xbootclassoath选项指定的jar包。由C++实现，不是ClassLoader子类。
- Extension ClassLoader 负责加载java平台中扩展功能的一些jar包，包括$JAVA_HOME中jre/lib/*.jar 或 -Djava.ext.dirs指定目录下的jar包。
- App ClassLoader 负责加载classpath中指定的jar包及-Djava.class.path所指定目录下的类和jar包。
- Custom ClassLoader 通过java.lang.classLoader 的子类自定义加载class，属于应用程序根据自定义的ClassLoader，如tomcat、jboss都会根据j2ee规范自行实现ClassLoader。
![](.README_images/af29b911.png)

### 加载原则

​	检查某个类是否己经加载：顺序是自底向上，从Custom ClassLoader到BootStrap ClassLoader逐层检查，只要某个ClassLoader已加载，就视为已加载，保证此类只加载过一次。

双亲委派机制

定义：如果一个类加载器在接到加载类的请求时，它首先不会自己尝试去加载这个类，而是把这个请求任务委托给父类加载器去完成，依次递归，如果父类加载器可以完成类加载任务，就成功返回；只有父类加载器无法完成此加载任务时，才会自己去加载。

优势：java类随着加载它的类加载器一起具备了一种带有优先级的层次关系。比如，java中的Object类，它存放在rt.jar之中，无论哪个类加载器要加载这个类，最终都会委托给处于模型最顶端的启动类进行加载，因此Object在各种类加载环境中都是同一个类。如果不采用双亲委派模型，那么由各个类加载器自己去加载的话，那么系统中会存在不同的Object类。

破坏：可以继承ClassLoader类，然后重写其中的loadClass方法。

加载器的特点：

1. 双亲委派
2. 负责依赖
3. 缓存加载

自定义ClassLoader

```java
package com.wenhao.classloader;

import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;

public class HelloClassLoader extends ClassLoader {

    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException {
        new HelloClassLoader().findClass("com.wenhao.bytecode.HelloDemo").newInstance();
    }

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        String myPath = "file:///Users/liuwenhao/code/jvm-learn/target/classes/com/wenhao/bytecode/HelloDemo.class";
        byte[] cLassBytes = null;
        Path path = null;
        try {
            path = Paths.get(new URI(myPath));
            cLassBytes = Files.readAllBytes(path);
        } catch (IOException | URISyntaxException e) {
            e.printStackTrace();
        }
        return defineClass(name, cLassBytes, 0, cLassBytes.length);
    }
}
```



# 内存结构

JVM内存整体结构

![](.README_images/757131d9.png)



### PC寄存器

#### 定义

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

#### 作用

程序计数器的作用就是记住下一条jvm指令的执行地址。

#### 特点

- 线程私有
- 不会存在内存溢出

### 虚拟机栈

![](.README_images/3c72a717.png)

​	栈的数据结构特点先进后出。虚拟机栈就是线程运行需要的内存空间，虚拟机栈由一个或者多个栈帧组成。栈帧是每个方法运行时需要的内存空间（局部变量、操作数栈（java没有寄存器，所有参数传递使用操作数栈）、常量指针、动态连接、方法返回值等）。每次方法调用创建一个栈帧，并压入栈，退出方法时，修改栈顶指针就可以吧栈帧中的内容销毁。栈帧是一个逻辑上的概念，具体的大小在一个方法编写完成后就基本上确定了。比如返回值需要多大的空间存储，每个局部变量需要对应的地址空间，此外还有给指令使用的操作数栈以及class指针（标识这个栈帧对应的是哪个类的方法，指向非堆里的Class对象）

​	局部变量表存放了编译期可知的各种类型的基本数据类型和引用类型，每个slot存放32位数据，long、double占两个槽位。

#### 定义

Java Virtual Machine Stacks （java 虚拟机栈）

- 每启动一个线程，JVM就会在栈空间分配对应的线程栈，比如1MB空间（-Xss1m）。线程栈也叫Java方法栈。如果使用JNI方法，则会分配一个单独的本地方法栈（Native Stack）。
- 线程执行过程中，一般会有多个方法组成调用栈（Stack Trace）,比如A调用B，B调用C。。每执行到一个方法，就会创建对应的栈帧（Frame）。
- 每个线程只能有一个活动栈帧，对应着当前执行的那个方法。

#### 问题

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

出栈内存自动释放，不需要垃圾回收

- 栈内存分配越大越好吗？

通过 -Xss size指定栈的大小。linux默认是1024KB。意为为每个虚拟机栈划分1M的内存。由于内存大小是固定的。假设是200M，这时可以支持200个虚拟机栈。如果给每个虚拟机栈划分2M的内存，那么只能支持100个虚拟机栈。从而影响线程数。所以不设置过大的栈内存，一般使用默认的即可。

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

```java
package com.example;

public class WenhaoTest {
    public static void main(String[] args) {
    }

    // sb 线程安全
    public static void m1() {
        StringBuilder sb = new StringBuilder();
        sb.append(1);
        sb.append(2);
        sb.append(3);
        System.out.println(sb.toString());
    }

    // sb 线程不安全
    public static void m2(StringBuilder sb) {
        sb.append(1);
        sb.append(2);
        sb.append(3);
        System.out.println(sb.toString());
    }

    // sb 线程不安全
    public static StringBuilder m3() {
        StringBuilder sb = new StringBuilder();
        sb.append(1);
        sb.append(2);
        sb.append(3);
        return sb;
    }
}
```

如果方法内局部变量没有逃离方法的作用范围，它就是线程安全的

如果是局部变量引用了对象，并逃离了方法的作用范围，则需要考虑线程安全。

#### 栈内存溢出

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

栈的大小是固定的。但是栈帧越来越多就会导致栈内存溢出（方法递归调用）

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



```java
/**
 * 演示栈内存溢出
 * -Xss 256k
 */
public class WenhaoTest {

    private static int count;

    public static void main(String[] args) {
        try {
            m1();
        } catch (Throwable e) {
            e.printStackTrace();
            // 打印递归次数
            System.out.println(count);
        }
    }

    private static void m1() {
        count++;
        m1();
    }
}
```





```java
package com.example;

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

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

/**
 * 演示栈内存溢出
 * -Xss 256k
 */
public class WenhaoTest {

    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();
        emp1.setName("lisi");
        emp1.setDept(dept);

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

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


    }
}

class Emp {
    private String name;
    // 解决循环依赖关系
    @JsonIgnore
    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;
    }
}
```



#### 线程运行诊断

案例1：cpu占用过多

- top / top -p pid -H 查看那个进程占用cpu过多

- ps H -eo  pid,tid,%cpu |grep 进程ID 定位是哪个线程对CPU占用过高 
- jstack 进程ID > 1.txt
- printf “%x” 十进制的线程id(拿到线程16进制的进程ID去1.txt文件看进程状态)

案例2：程序运行很长时间没有结果（死循环、死锁）

jstack 进程ID> jstack.txt



```java
package com.wenhao.controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.ArrayList;
import java.util.List;
 
@RestController
public class CpuController {
    /**
     * 模拟死循环
     * @return
     */
    @GetMapping("loop")
    public List<Long> loop(){
        String data = "{\"data\":[{\"partnerid\":]";
        return getPartneridsFromJson(data);
    }
    /**
     * 模拟死锁
     * @return
     */
    @GetMapping("deadlock")
    public String deadlock(){
        Object o1 = new Object();
        Object o2 = new Object();
        new Thread(()->{
            synchronized (o1) {
                try {Thread.sleep(1000);}catch(Exception e) {}
                synchronized(o2) {
                    System.out.println("Thread1 over");
                }
            }
        }).start();
 
        new Thread(()->{
            synchronized (o2){
                try {Thread.sleep(1000);}catch(Exception e) {}
                synchronized(o1) {
System.out.println("Thread2 over");
                }
            }
        }).start();
        return "deadlock";
    }
 
    public static List<Long> getPartneridsFromJson(String data){
        //{\"data\":[{\"partnerid\":982,\"count\":\"10000\",\"cityid\":\"11\"},{\"partnerid\":983,\"count\":\"10000\",\"cityid\":\"11\"},{\"partnerid\":984,\"count\":\"10000\",\"cityid\":\"11\"}]}
        //上面是正常的数据
        List<Long> list = new ArrayList<Long>(2);
        if(data == null || data.length() <= 0){
            return list;
        }
        int datapos = data.indexOf("data");
        if(datapos < 0){
            return list;
        }
        int leftBracket = data.indexOf("[",datapos);
        int rightBracket= data.indexOf("]",datapos);
        if(leftBracket < 0 || rightBracket < 0){
            return list;
        }
        String partners = data.substring(leftBracket+1,rightBracket);
        if(partners == null || partners.length() <= 0){
            return list;
        }
        while(partners!=null && partners.length() > 0){
            int idpos = partners.indexOf("partnerid");
            if(idpos < 0){
                break;
            }
            int colonpos = partners.indexOf(":",idpos);
            int commapos = partners.indexOf(",",idpos);
            if(colonpos < 0 || commapos < 0){
                //partners = partners.substring(idpos+"partnerid".length());//1
                continue;
            }
            String pid = partners.substring(colonpos+1,commapos);
            if(pid == null || pid.length() <= 0){
                //partners = partners.substring(idpos+"partnerid".length());//2
                continue;
            }
            try{
                list.add(Long.parseLong(pid));
            }catch(Exception e){
                //do nothing
            }
            partners = partners.substring(commapos);
        }
        return list;
    }
}
```

### 本地方法栈

本地方法栈（Native Method Stacks）与虚拟机栈所发挥的作用是非常相似的，他们之间的区别不过是虚拟机栈为虚拟机执行Java方法（也就是字节码）服务，而本地方法栈则是虚拟机使用到的Native方法服务。

### 堆

​	堆内存是所有线程公用的内存空间，JVM将Heap内存分为年轻代（Young generation）和老年代（Old generation，也叫Tenured）两部分。

​	年轻代还划分为3个内存池，新生代（Eden space）和存活区（Survivor space），在大部分GC算法中有2个存活区（s0，s1）默认Eden:s0:s1=8:1:1，在我们可以观察到的任一时刻，s0和s1总有一个是空的，但是s0和s1占有的空间比较小不会产生太多的空间浪费。总有一个空间是空的是因为垃圾回收过程会将A空间中有用的对象挪到B空间， 在吧A空间的对象清空。

​	Non-Heap本质上还是Heap，只是一般不归GC管理，里面划分为3个内存池。

- Metaspace，之前叫持久代（永久代，Permanent generation），java8换了个名字叫Metaspace。
- CCS，Compressed Class Space，存放class信息和Metaspace有交叉
- Code Cache，存放JIT编译器编译后的本地机器代码

![](.README_images/a4ea2897.png)



#### 定义

Heap 堆

- Java堆用于存放应用系统创建的对象和数组，所有线程共享Java堆。
- java堆在运行期间动态分配内存大小，自动进行垃圾回收。
- java垃圾回收（GC）主要就是回收堆内存，对分代GC来说，堆也是分代的。

特点

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

#### 堆内存溢出

```java
package com.example;
import java.util.ArrayList;
import java.util.List;
/**
 * 演示堆内存溢出
 * -Xmx8m
 */
public class WenhaoTest {

    public static void main(String[] args) {

        int i = 0;
        try {
            List<String> list = new ArrayList<>();
            String a = "hello";
            while (true) {
                list.add(a);
                a = a + a;
                i++;
            }
        } catch (Throwable e) {
            e.printStackTrace();
            System.out.println(i);
        }
    }
}
```



#### 堆内存诊断

- jps 工具

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

- jmap 工具

查看堆内存占用情况

```java
package com.example.jvm;

public class Demo_heap {

    public static void main(String[] args) throws InterruptedException {
        System.out.println("1");
        Thread.sleep(30000);
        byte[] bytes = new byte[1024 * 1024 * 10]; // 10M
        System.out.println("2");
        Thread.sleep(30000);
        bytes = null;
        System.gc();
        System.out.println("3jps");
        Thread.sleep(1000000L);
    }
}
```

jps + jmap 查看 堆内存

```
G:\workspace\study2020\demo>jps
31248 Demo_heap
13508
24248 RemoteMavenServer36
25448 Jps
19228
35788 Launcher
// 时间点 1
G:\workspace\study2020\demo>jmap -heap 31248
Attaching to process ID 31248, please wait...
Debugger attached successfully.
Server compiler detected.
JVM version is 25.141-b15

using thread-local object allocation.
Parallel GC with 8 thread(s)

Heap Configuration:
   MinHeapFreeRatio         = 0
   MaxHeapFreeRatio         = 100
   MaxHeapSize              = 4253024256 (4056.0MB)
   NewSize                  = 88604672 (84.5MB)
   MaxNewSize               = 1417674752 (1352.0MB)
   OldSize                  = 177733632 (169.5MB)
   NewRatio                 = 2
   SurvivorRatio            = 8
   MetaspaceSize            = 21807104 (20.796875MB)
   CompressedClassSpaceSize = 1073741824 (1024.0MB)
   MaxMetaspaceSize         = 17592186044415 MB
   G1HeapRegionSize         = 0 (0.0MB)

Heap Usage:
PS Young Generation
Eden Space:
   capacity = 66584576 (63.5MB)
   used     = 6659056 (6.3505706787109375MB)
   free     = 59925520 (57.14942932128906MB)
   10.000898706631398% used
From Space:
   capacity = 11010048 (10.5MB)
   used     = 0 (0.0MB)
   free     = 11010048 (10.5MB)
   0.0% used
To Space:
   capacity = 11010048 (10.5MB)
   used     = 0 (0.0MB)
   free     = 11010048 (10.5MB)
   0.0% used
PS Old Generation
   capacity = 177733632 (169.5MB)
   used     = 0 (0.0MB)
   free     = 177733632 (169.5MB)
   0.0% used

3180 interned Strings occupying 260520 bytes.

// 时间点 2
G:\workspace\study2020\demo>jmap -heap 31248
Attaching to process ID 31248, please wait...
Debugger attached successfully.
Server compiler detected.
JVM version is 25.141-b15

using thread-local object allocation.
Parallel GC with 8 thread(s)

Heap Configuration:
   MinHeapFreeRatio         = 0
   MaxHeapFreeRatio         = 100
   MaxHeapSize              = 4253024256 (4056.0MB)
   NewSize                  = 88604672 (84.5MB)
   MaxNewSize               = 1417674752 (1352.0MB)
   OldSize                  = 177733632 (169.5MB)
   NewRatio                 = 2
   SurvivorRatio            = 8
   MetaspaceSize            = 21807104 (20.796875MB)
   CompressedClassSpaceSize = 1073741824 (1024.0MB)
   MaxMetaspaceSize         = 17592186044415 MB
   G1HeapRegionSize         = 0 (0.0MB)

Heap Usage:
PS Young Generation
Eden Space:
   capacity = 66584576 (63.5MB)
   used     = 17144832 (16.3505859375MB)
   free     = 49439744 (47.1494140625MB)
   25.748954232283463% used
From Space:
   capacity = 11010048 (10.5MB)
   used     = 0 (0.0MB)
   free     = 11010048 (10.5MB)
   0.0% used
To Space:
   capacity = 11010048 (10.5MB)
   used     = 0 (0.0MB)
   free     = 11010048 (10.5MB)
   0.0% used
PS Old Generation
   capacity = 177733632 (169.5MB)
   used     = 0 (0.0MB)
   free     = 177733632 (169.5MB)
   0.0% used

3181 interned Strings occupying 260568 bytes.

// 时间点 3
G:\workspace\study2020\demo>jmap -heap 31248
Attaching to process ID 31248, please wait...
Debugger attached successfully.
Server compiler detected.
JVM version is 25.141-b15

using thread-local object allocation.
Parallel GC with 8 thread(s)

Heap Configuration:
   MinHeapFreeRatio         = 0
   MaxHeapFreeRatio         = 100
   MaxHeapSize              = 4253024256 (4056.0MB)
   NewSize                  = 88604672 (84.5MB)
   MaxNewSize               = 1417674752 (1352.0MB)
   OldSize                  = 177733632 (169.5MB)
   NewRatio                 = 2
   SurvivorRatio            = 8
   MetaspaceSize            = 21807104 (20.796875MB)
   CompressedClassSpaceSize = 1073741824 (1024.0MB)
   MaxMetaspaceSize         = 17592186044415 MB
   G1HeapRegionSize         = 0 (0.0MB)

Heap Usage:
PS Young Generation
Eden Space:
   capacity = 66584576 (63.5MB)
   used     = 1331712 (1.27001953125MB)
   free     = 65252864 (62.22998046875MB)
   2.0000307578740157% used
From Space:
   capacity = 11010048 (10.5MB)
   used     = 0 (0.0MB)
   free     = 11010048 (10.5MB)
   0.0% used
To Space:
   capacity = 11010048 (10.5MB)
   used     = 0 (0.0MB)
   free     = 11010048 (10.5MB)
   0.0% used
PS Old Generation
   capacity = 177733632 (169.5MB)
   used     = 1339512 (1.2774581909179688MB)
   free     = 176394120 (168.22254180908203MB)
   0.7536626495091261% used

3167 interned Strings occupying 259576 bytes.

```

- jconsole 工具

```
G:\workspace\study2020\demo>jconsole
```

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

jvisualvm

点击堆 Dump 抓取 hprof快照

查询占用内存比较大的对象

分析对象的组成

案例源码：

```java
package com.example.jvm;

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

public class Demo1_13 {

    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(1000000000L);
    }
}

class Student {
    private byte[] big = new byte[1024 * 1024];
}
```

#### 对象的内存布局

​	对象在内存中存储的布局（这里以HotSpot虚拟机位例来说），分为：对象头、实例数据和对齐填充。

​	对象头，包含两部分：

- Mark Word：存储对象自身的运行数据，如：HashCode、GC分代年龄、锁状态标志等。
- 类型指针：对象指向它的类元数据的指针。
- 实例数据：真正存放对象实例数据的地方
- 对齐填充：这部分不一定存在，也没有什么特别的含义，仅仅是占位符。因为HotSpot要求对象起始地址都是8字节的整数倍，如果不是，就需要对齐。

##### 对象的访问定位

​	在JVM规范只规定了reference类型是一个指向对象的引用，但没有规定这个引用如何去定位、访问具体位置。因此对象的访问方式取决于JVM的实现，一般通过实现句柄或者指针这两种方式。

- 使用句柄：Java堆中会划分出一块内存来做为句柄池，reference中存储句柄的地址，句柄中存储对象的实例数据和元数据的地址，如下图：
  ![](.README_images/f5c49f15.png)

- 使用指针：Java堆中会存放访问类元数据的地址，reference存储的就是对象的地址，如下图：
  ![](.README_images/05efa156.png)
  使用句柄的优势在于在对象移动后只需修改句柄池中的指针，不需要修改reference。因为reference是直接引用的句柄池，句柄池的中指针再指向对象实例，正因为如此，运行的数据会稍慢些，因为进行了两次指针定位。使用指针的优势在于只需要一次指针定位速度快，Hotspot中使用的是采用指针的方式。


### 方法区

#### 定义

​	方法区于Java堆一样，是各个线程共享的内存区域，它用于存储已被虚拟机加载的**类信息、常量、静态变量、即时编译器编译后的代码**等数据。虽然Java虚拟机规范把方法区描述为堆的一个逻辑部分，但是它却有一个别名叫做Non-Heap（非堆），目的是与Java堆区分开来。

​	当方法区无法满足内存分配需求时，将抛出OutOfMemoryError异常。方法区在JDK8中就是Metaspace，在JDK6或者7中就是Perm Space

#### 方法区内存溢出

```java
package com.example.jvm;

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

/**
 * 演示元空间内存溢出
 * -XX:MaxMetaspaceSize=8m  如果是jdk8之前的版本用的是永久代 -XX:MaxPermSize=8m java.lang.OutOfMemoryError: PermGen space
 */
public class Demo1_8 extends ClassLoader { // 用来加载类的二进制字节码

    public static void main(String[] args) {
        int j = 0;
        try {
            Demo1_8 demo1_8 = new Demo1_8();
            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();
                // 加载类
                demo1_8.defineClass("Class" + i, code, 0, code.length);
            }
        } finally {
            System.out.println(j);
        }
    }
}
```



### 运行时常量池

#### 定义

常量池Run-Time Constant Pool

Class文件中除了有**类的版本、字段、方法、接口描述信息**外，还有一项信息是常量池（Constant Pool Table），用于存放编译期生成的各种字面量和符号引用，这部分内容将在类加载后进入方法区的运行时常量池中存放。**运行时常量池（Runtime Constant Pool）是方法区的一部分**，常量池是*.class文件中的，当该类被加载，它的常量池信息就会放入运行时常量池，并把里面的符号地址变为真实地址。

```java
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package com.example.jvm;

public class HelloWorld {
    public HelloWorld() {
    }

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

```java
javap -v HelloWorld.class
```

```c#
Classfile /G:/workspace/study2020/demo/target/test-classes/com/example/jvm/HelloWorld.class
  Last modified 2020-4-27; size 565 bytes
  MD5 checksum 3e4924d19da8156d476a30190cf41cd1
  Compiled from "HelloWorld.java"
public class com.example.jvm.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/example/jvm/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/example/jvm/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/example/jvm/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.example.jvm.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 4: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       5     0  this   Lcom/example/jvm/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"

```



### StringTable

面试题：

```java
package com.example.jvm;

public class HelloWorld {
    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();

        // 问
        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";
        String x3 = x2.intern(); // 将这个字符串对象尝试放入串池，如果有则不放入，如果没有则放入。会把串池中的对象返回

        // 问，如果调换了【最后两行代码】的位置呢，如果是jdk1.6呢
        System.out.println(x1 == x2); 
        // 调换前 false 这时串池中已有 ab 所以不能放入串池
        // 调换后 true
        // 如果是1.6 调换前 false 调换后 false
        
        System.out.println(x3 == x1); // x3是串池中的对象，所以这里是true
    }
}

```



```java
package com.example.jvm;

// --> StringTable[ "a", "b", "ab" ] hashtable结构，不能扩容
public class Demo1_22 {
    // 常量池中的信息，都会被加载到运行时常量池中，这时 a b ab 都是常量池中的符号，还没有变为java字符串对象
    // ldc #2 会把a符号变为"a"字符串对象，将字符串对象放入StringTable（串池）中
    // ldc #3 会把b符号变为"b"字符串对象，将字符串对象放入StringTable（串池）中
    // ldc #4 会把ab符号变为"ab"字符串对象，将字符串对象放入StringTable（串池）中
    public static void main(String[] args) {
        String s1 = "a";
        String s2 = "b";
        String s3 = "ab";
    }
}

```

```java
javap -v Demo1_22.class
```

```c#
Classfile /G:/workspace/study2020/demo/target/test-classes/com/example/jvm/Demo1_22.class
  Last modified 2020-4-27; size 692 bytes
  MD5 checksum 80dc30859e9b084311828cea9e313af6
  Compiled from "Demo1_22.java"
public class com.example.jvm.Demo1_22
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Methodref          #10.#29        // java/lang/Object."<init>":()V
   #2 = String             #30            // a
   #3 = String             #31            // b
   #4 = String             #32            // ab
   #5 = Class              #33            // java/lang/StringBuilder
   #6 = Methodref          #5.#29         // java/lang/StringBuilder."<init>":()V
   #7 = Methodref          #5.#34         // java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
   #8 = Methodref          #5.#35         // java/lang/StringBuilder.toString:()Ljava/lang/String;
   #9 = Class              #36            // com/example/jvm/Demo1_22
  #10 = Class              #37            // java/lang/Object
  #11 = Utf8               <init>
  #12 = Utf8               ()V
  #13 = Utf8               Code
  #14 = Utf8               LineNumberTable
  #15 = Utf8               LocalVariableTable
  #16 = Utf8               this
  #17 = Utf8               Lcom/example/jvm/Demo1_22;
  #18 = Utf8               main
  #19 = Utf8               ([Ljava/lang/String;)V
  #20 = Utf8               args
  #21 = Utf8               [Ljava/lang/String;
  #22 = Utf8               s1
  #23 = Utf8               Ljava/lang/String;
  #24 = Utf8               s2
  #25 = Utf8               s3
  #26 = Utf8               s4
  #27 = Utf8               SourceFile
  #28 = Utf8               Demo1_22.java
  #29 = NameAndType        #11:#12        // "<init>":()V
  #30 = Utf8               a
  #31 = Utf8               b
  #32 = Utf8               ab
  #33 = Utf8               java/lang/StringBuilder
  #34 = NameAndType        #38:#39        // append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
  #35 = NameAndType        #40:#41        // toString:()Ljava/lang/String;
  #36 = Utf8               com/example/jvm/Demo1_22
  #37 = Utf8               java/lang/Object
  #38 = Utf8               append
  #39 = Utf8               (Ljava/lang/String;)Ljava/lang/StringBuilder;
  #40 = Utf8               toString
  #41 = Utf8               ()Ljava/lang/String;
{
  public com.example.jvm.Demo1_22();
    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 4: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       5     0  this   Lcom/example/jvm/Demo1_22;

  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=5, args_size=1
         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
        29: return
      LineNumberTable:
        line 10: 0
        line 11: 3
        line 12: 6
        line 13: 9
        line 14: 29
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      30     0  args   [Ljava/lang/String;
            3      27     1    s1   Ljava/lang/String;
            6      24     2    s2   Ljava/lang/String;
            9      21     3    s3   Ljava/lang/String;
           29       1     4    s4   Ljava/lang/String;
}
SourceFile: "Demo1_22.java"

```



#### 特性

- 常量池中的字符串仅是符号，第一次用到才变成对象
- 利用串池的机制，来避免重复创建字符串对象
- 字符串拼接的原理是StringBuilder (1.8)
- 可以使用intern方法，
  - 1.8 将这个字符串对象尝试放入串池，如果有则不放入，如果没有则放入。会把串池中的对象返回
  - 1.6 将这个字符串对象尝试放入串池，如果有则不放入，如果没有则拷贝一份放入串池。会把串池中的对象返回

#### StringTable的位置

1.6中它存在于PerGen 永久代中的常量池中，在1.8中，它存在于堆 Heap中。这样的转变是为了更好的回收垃圾。

#### 验证StringTable所在位置

```java
package com.example.jvm;

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

/**
 * 演示 StringTable位置
 * 在jdk8下设置 -Xmx10m -XX:-UseGCOverheadLimit
 * 在jdk6下设置 -XX:MaxPermSize=10m
 */
public class Demo1_6 {

    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        int i = 0;
        try {
            for (int j = 0; j < 260000; j++) {
                // 将j作为字符串加入串池中，并且把字符串加入到list中防止被垃圾回收
                list.add(String.valueOf(j).intern());
                i++;
            }
        } catch (Throwable e) {
            e.printStackTrace();
        } finally {
            System.out.println(i);
        }
    }
}
// -XX:+UseGCOverheadLimit :This option is enabled,by default, and the parallel GC will throw an OutOfMemoryError if more than 98% of the total time is spent on garbage collection and less than 2% of the heap is recovered.
```

1.8中运行：

```java
java.lang.OutOfMemoryError: Java heap space
```

1.6中运行：

```java
java.lang.OutOfMemoryError: PermGen space
```



#### StringTable垃圾回收

```java
package com.example.jvm;

/**
 * 演示 StringTable 垃圾回收
 * -Xmx10m -XX:+PrintStringTableStatistics -XX:+PrintGCDetails -verbose:gc
 */
public class Demo1_7 {
    public static void main(String[] args) {
        int i = 0;
        try {
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            System.out.println(i);
        }
    }
}
```

执行结果：

```c#
[GC (Allocation Failure) [PSYoungGen: 2048K->512K(2560K)] 2048K->902K(9728K), 0.0018141 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
0
Heap
 PSYoungGen      total 2560K, used 1852K [0x00000000ffd00000, 0x0000000100000000, 0x0000000100000000)
  eden space 2048K, 65% used [0x00000000ffd00000,0x00000000ffe4f310,0x00000000fff00000)
  from space 512K, 100% used [0x00000000fff00000,0x00000000fff80000,0x00000000fff80000)
  to   space 512K, 0% used [0x00000000fff80000,0x00000000fff80000,0x0000000100000000)
 ParOldGen       total 7168K, used 390K [0x00000000ff600000, 0x00000000ffd00000, 0x00000000ffd00000)
  object space 7168K, 5% used [0x00000000ff600000,0x00000000ff661a18,0x00000000ffd00000)
 Metaspace       used 3329K, capacity 4556K, committed 4864K, reserved 1056768K
  class space    used 355K, capacity 392K, committed 512K, reserved 1048576K
Disconnected from the target VM, address: '127.0.0.1:64028', transport: 'socket'
SymbolTable statistics:
Number of buckets       :     20011 =    160088 bytes, avg   8.000
Number of entries       :     13818 =    331632 bytes, avg  24.000
Number of literals      :     13818 =    596704 bytes, avg  43.183
Total footprint         :           =   1088424 bytes
Average bucket size     :     0.691
Variance of bucket size :     0.691
Std. dev. of bucket size:     0.832
Maximum bucket size     :         6
StringTable statistics: // 底层的实现是HashTable 数组 + 链表，数组的个数叫桶 buckets
Number of buckets       :     60013 =    480104 bytes, avg   8.000 // 
Number of entries       :      1729 =     41496 bytes, avg  24.000 // 字符串对象个数
Number of literals      :      1729 =    156360 bytes, avg  90.434 // 字符串常量个数
Total footprint         :           =    677960 bytes
Average bucket size     :     0.029
Variance of bucket size :     0.029
Std. dev. of bucket size:     0.170
Maximum bucket size     :         2
```

```java
package com.example.jvm;

/**
 * 演示 StringTable 垃圾回收
 * -Xmx10m -XX:+PrintStringTableStatistics -XX:+PrintGCDetails -verbose:gc
 */
public class Demo1_7 {
    public static void main(String[] args) {
        int i = 0;
        try {
            for (int j = 0; j < 100; j++) {
                String.valueOf(j).intern();
                i++;
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            System.out.println(i);
        }

    }
}
```

执行结果：

```c#
[GC (Allocation Failure) [PSYoungGen: 2048K->488K(2560K)] 2048K->905K(9728K), 0.0014345 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
100
Heap
 PSYoungGen      total 2560K, used 1831K [0x00000000ffd00000, 0x0000000100000000, 0x0000000100000000)
  eden space 2048K, 65% used [0x00000000ffd00000,0x00000000ffe4fe60,0x00000000fff00000)
  from space 512K, 95% used [0x00000000fff00000,0x00000000fff7a020,0x00000000fff80000)
  to   space 512K, 0% used [0x00000000fff80000,0x00000000fff80000,0x0000000100000000)
 ParOldGen       total 7168K, used 417K [0x00000000ff600000, 0x00000000ffd00000, 0x00000000ffd00000)
  object space 7168K, 5% used [0x00000000ff600000,0x00000000ff6686d0,0x00000000ffd00000)
 Metaspace       used 3329K, capacity 4556K, committed 4864K, reserved 1056768K
  class space    used 355K, capacity 392K, committed 512K, reserved 1048576K
Disconnected from the target VM, address: '127.0.0.1:64657', transport: 'socket'
SymbolTable statistics:
Number of buckets       :     20011 =    160088 bytes, avg   8.000
Number of entries       :     13818 =    331632 bytes, avg  24.000
Number of literals      :     13818 =    596704 bytes, avg  43.183
Total footprint         :           =   1088424 bytes
Average bucket size     :     0.691
Variance of bucket size :     0.691
Std. dev. of bucket size:     0.832
Maximum bucket size     :         6
StringTable statistics:
Number of buckets       :     60013 =    480104 bytes, avg   8.000
Number of entries       :      1829 =     43896 bytes, avg  24.000 // 字符串对象 +100
Number of literals      :      1829 =    161160 bytes, avg  88.114
Total footprint         :           =    685160 bytes
Average bucket size     :     0.030
Variance of bucket size :     0.031
Std. dev. of bucket size:     0.175
Maximum bucket size     :         2
```



执行结果：

```c#
[GC (Allocation Failure) [PSYoungGen: 2048K->488K(2560K)] 2048K->950K(9728K), 0.0016209 secs] [Times: user=0.00 sys=0.00, real=0.00 secs]  // 触发了GC
10000
Heap
 PSYoungGen      total 2560K, used 2310K [0x00000000ffd00000, 0x0000000100000000, 0x0000000100000000)
  eden space 2048K, 88% used [0x00000000ffd00000,0x00000000ffec7880,0x00000000fff00000)
  from space 512K, 95% used [0x00000000fff00000,0x00000000fff7a020,0x00000000fff80000)
  to   space 512K, 0% used [0x00000000fff80000,0x00000000fff80000,0x0000000100000000)
 ParOldGen       total 7168K, used 462K [0x00000000ff600000, 0x00000000ffd00000, 0x00000000ffd00000)
  object space 7168K, 6% used [0x00000000ff600000,0x00000000ff673a08,0x00000000ffd00000)
 Metaspace       used 3332K, capacity 4556K, committed 4864K, reserved 1056768K
  class space    used 355K, capacity 392K, committed 512K, reserved 1048576K
Disconnected from the target VM, address: '127.0.0.1:64780', transport: 'socket'
SymbolTable statistics:
Number of buckets       :     20011 =    160088 bytes, avg   8.000
Number of entries       :     13818 =    331632 bytes, avg  24.000
Number of literals      :     13818 =    596704 bytes, avg  43.183
Total footprint         :           =   1088424 bytes
Average bucket size     :     0.691
Variance of bucket size :     0.691
Std. dev. of bucket size:     0.832
Maximum bucket size     :         6
StringTable statistics:
Number of buckets       :     60013 =    480104 bytes, avg   8.000
Number of entries       :     11652 =    279648 bytes, avg  24.000 // +9,923 并没有增加10000个字符串，因为出发了GC
Number of literals      :     11652 =    633064 bytes, avg  54.331
Total footprint         :           =   1392816 bytes
Average bucket size     :     0.194
Variance of bucket size :     0.208
Std. dev. of bucket size:     0.457
Maximum bucket size     :         3
```

#### StringTable 性能调优

###### 调整 -XX:StringTableSize=桶个数

StringTable底层是HashTable，桶的个数 buckets多，元素就比较分散，hash碰撞的几率就减小，查找的速度就会变快。反之元素就比较集中，hash碰撞的几率就变大，导致链表较长，从而使查询速度变慢。

```java
package com.example.jvm;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;

/**
 * -XX:PrintStringTableStatistics -XX:StringTableSize=20000
 */
public class Demo1_24 {
    public static void main(String[] args) throws IOException {
        try (BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream("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);
        }
    }
}
// StringTable size must be between 1009 and 23054843009213693051
```

得出的结论，buckets的值越大的话执行的速度越快。buckets越多，则它下边的链表长度就越短，节省了排除校验是否有重复字符串的时间。

###### 考虑将字符串对象是否入池

字符串很多，但是有好多重复字符串，这时可以通过intern函数使字符串对象入池，从而减小字符串对内存的占用。

### 直接内存

#### 定义

Direct Memory

- 常见于NIO操作时，用于数据缓存
- 分配回收成本较高，但是读写性能高
- 不受JVM内存回收管理

划分出来的直接内存，java堆内存和系统内存都能读到。减少了缓存区之间复制的工作。



### 堆栈方法去交互关系

![](.README_images/2566e6dd.png)

# JVM启动参数

​	JVM中有很多的参数可以进行设置，这样可以让jvm在各种环境中能够高效的运行，绝大多数参数保持默认即可。

​	JVM的参数类型分为3类，分别是：

1. 以-开头的**标准参数**，所有的JVM都要实现这些参数，并且向后兼容，例如：`-server`

   -D 设置系统属性，例如：`-Dfile.encoding=UTF-8`

2. -X 开头的**非标准参数**，基本都是传给JVM的，默认JVM实现这些参数的功能，但是并不保证所有JVM都满足，且不保证向后兼容。可以通过`java -X` 命令查看当前JVM支持的非标准参数。例如：`-Xmx8g`

3. 以-XX开头的**非稳定参数**，专门用于控制JVM的行为，跟具体的JVM实现有关，随时可能会在下个版本取消

   - `-XX:+-Flags` 形式，+-是对布尔值进行开关。例如：`-XX:+UseG1GC`
   - `-XX:key=value` 形式，指定某个选项的值。例如：`-XX:MaxPermSize=256m`

同时可以根据功能划分为一下6类：

1. 系统属性参数
2. 运行模式参数
3. 堆内存设置参数
4. GC设置参数
5. 分析诊断参数
6. JavaAgent参数

## 系统属性参数

用于设置系统属性，例如：`-Dmaven.test.skip=true`

在java代码里可以通过`System.getProperty("maven.test.skip")`获取到所设置的值。

## 运行模式参数

1. `-server`：设置JVM使用server模式，特点是启动速度比较慢，但是运行性能和内存管理效率很高，适用于生产环境。在具有64位能力的JDK环境下将默认启用该模式，而忽略-client参数。
2. `-client`：JDK1.7之前在32位的x86机器上默认值是-client选项。设置JVM使用client模式，特点是启动速度较快，但是运行时性能和内存管理效率不高，通常用于客户端应用程序或者PC应用开发和调试。
3. `-Xint`：在解释模式（interprered mode）下运行，-Xint标记会强制JVM解释执行所有的字节码，当然这会降低运行速度，通常低10倍或者更多。
4. `-Xcomp`：-Xcomp参数与-Xint相反，JVM在第一次使用时会把所有的字节码编译成本地代码从而带来更大程度的优化。
5. `-Xmixed`：-Xmixed时混合模式，将解释模式和编译模式进行混合使用，由JVM自己决定，这是JVM的默认模式，也是推荐模式。使用java -version可以看到mixed mode等信息。

## 堆内存参数

- `-Xmx`，指定最大堆内存,默认是物理内存的1/4。如-Xmx4g。这只是限制了Heap部分的最大值为4g。这个内存不包括栈内存，也不包括堆外使用的内存。（一般设置为机器内存的70%）
- `-Xms`，指定堆内存空间的初始大小,默认是物理内存的1/64。如-Xms4g。而且指定的内存大小并不是操作系统实际分配的初始值而是GC先规划好，用到才分配。专用服务器上需要保持-Xms和-Xmx一致，否则应用刚启动可能就有好几个FullGC。当两者配置不一致时，堆内存扩展可能导致性能抖动。
- `-Xmn`，等价于-XX:NewSize，默认是整个堆的3/8，**使用G1垃圾收集器不应该设置该选项**，其他的某些场景下可以设置。官方建议设置为-Xmx的1/2～1/4。
- `-XX:MaxPermSize=size`，这是JDK1.7之间使用的。Java8默认允许的Meta空间无限大，次参数无效。
- `-XX:MaxMetaspaceSize=size`，Java8默认不限制Meta空间，一般不允许设置该选项。
- `-XX:MaxDirectMemorySize=size`，系统可以使用的最大堆外内存，这个参数跟`-Dsun.nioMaxDirectMemorySize`效果相同。
- `-Xss`：设置每个线程栈的字节数。例如：-Xss1m指定线程栈为1MB，与-XX:ThreadStackSize=1m等效。

## GC相关参数

- `-XX:+UseG1GC`：使用G1垃圾回收器
- `-XX:+UseConcMarkSweepGC`：使用CMS垃圾回收器
- `-XX:+UseSerialGC`：使用串行垃圾回收器
- `-XX:+UseParallelGC`：使用并行垃圾回收器
- `-XX:+UnlockExperimentalVMOptions -XX:+UseZGC` // java 11+
- `-XX:+UnlockExperimentalVMOptions -XX:+UseShenandoahGC` //java12+



## 分析诊断参数

- `-XX:+-HeapDumpOnOutOfMemoryError`选项，当OutOfMemoryError产生，即内存溢出（堆内存或持久代）时，会自动Dump堆内存。
  - 示例：`java -XX:+HeapDumpOnOutOfMemoryError -Xms256m ConsumeHeap`
- `-XX:HeapDumpPath`选项，与HeapDumpOnOutOfMemoryError搭配使用，指定内存溢出时Dump文件的目录
  - 示例：`java -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=/usr/local/ ConsumerHeap` 自动Dump的hprof文件会存储到/urs/local目录下
- `-XX:OnError`选项，发生致命错误时（fatal error）执行的脚本。
- `-XX:OnOutOfMemoryError`，抛出OutOfMemoryError错误执行的脚本
- `-XX:ErrorFile=fileName`，致命错误的日志文件名，绝对路径或者相对路径
- `-Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=1506`，远程调试



### Trace跟踪(高版本说明)参数

https://docs.oracle.com/en/java/javase/13/docs/specs/man/java.html

- 打印GC的简要信息： -Xlog:gc
- 打印GC详细信息：-Xlog:gc*
- 指定GC log位置，以文件输出：-Xlog:gc:*filename*
- 每次GC后，打印堆信息：-Xlog:gc+heap=debug

![](.README_images/613ede2d.png)



## JavaAgent参数

​	Agent是JVM中的一项黑科技，可以通过无侵入方式做很多事情，比如注入AOP代码，执行系统计算等等，权限非常大。

设置 agent 的语法如下:

- -agentlib:libname[=options] 启用 native 方式的 agent, 参考 LD_LIBRARY_PATH 路径。

- -agentpath:pathname[=options] 启用 native 方式的 agent。 

- -javaagent:jarpath[=options] 启用外部的 agent 库, 比如 pinpoint.jar 等等。

- -Xnoagent 则是禁用所有 agent。 

以下示例开启 CPU 使用时间抽样分析:

JAVA_OPTS="-agentlib:hprof=cpu=samples,file=cpu.samples.log"

# 工具

JDK内置命令行工具

| 工具           | 简介                                                         |
| -------------- | ------------------------------------------------------------ |
| java           | Java应用的启动程序                                           |
| javac          | JDK内置的编译工具                                            |
| javap          | 反编译class文件的工具                                        |
| javadoc        | 根据Java代码和标准注释，自动生成相关的API说明文档            |
| javah          | JNI开发时，根据java代码生成需要的.h文件                      |
| extcheck       | 检查某个jar文件和运行时拓展jar有没有版本冲突，很少使用       |
| jdb            | Java Debugger；可以调试本地和远端程序，属于JPDA中的一个demo实现，供其他调试器参考。开发时很少使用 |
| jdeps          | 探测class或jar包需要的依赖                                   |
| jar            | 打包工具，可以将文件和目录打包成为`.jar`文件;`.jar`文件本质就是zip文件，只是后缀不同。使用时按顺序对应好选项和参数即可 |
| keytool        | 安全证书和密钥的管理工具；（支持生成、导入、导出等操作）     |
| jarsigner      | JAR文件签名和验签工具                                        |
| policytool     | 实际上这就是一款图形界面工具，管理本机的java安全策略         |
| jps/jinfo      | 查看java进程信息                                             |
| jstat          | 查看JVM内部gc相关信息                                        |
| jmap           | 查看heap或类占用空间统计                                     |
| jstack         | 查看线程信息                                                 |
| jcmd           | 执行JVM相关分析命令（整合命令）                              |
| Jrunscript/jjs | 执行js命令                                                   |

## jps/jinfo
![](.README_images/113ffa9a.png)
基本上只能看到pid。可以加上参数`-mlvV`查看详细信息
![](.README_images/b33bc6ba.png)
jinfo pid查看进程详细信息，进程使用的jvm内存参数
![](.README_images/c36c1648.png)

```
jinfo -flag MaxHeapSize pid（查看进程最大堆内存）
jinfo -flag UseConcMarkSweepGC pid（查看垃圾回收器）
jinfo -flag UseG1GC pid (查看是否开启G1GC)
jinfo -flag UseParallelGC pid （查看是否开启ParallelGC）
```



## jstat

```
Usage: jstat -help|-options
       jstat -<option> [-t] [-h<lines>] <vmid> [<interval> [<count>]]

Definitions:
  <option>      An option reported by the -options option
  <vmid>        Virtual Machine Identifier. A vmid takes the following form:
                     <lvmid>[@<hostname>[:<port>]]
                Where <lvmid> is the local vm identifier for the target
                Java virtual machine, typically a process id; <hostname> is
                the name of the host running the target Java virtual machine;
                and <port> is the port number for the rmiregistry on the
                target host. See the jvmstat documentation for a more complete
                description of the Virtual Machine Identifier.
  <lines>       Number of samples between header lines.
  <interval>    Sampling interval. The following forms are allowed:
                    <n>["ms"|"s"]
                Where <n> is an integer and the suffix specifies the units as
                milliseconds("ms") or seconds("s"). The default units are "ms".
  <count>       Number of samples to take before terminating.
  -J<flag>      Pass <flag> directly to the runtime system.
```



```c#
[root@sf105220 ~]# jstat -options
-class //类加载（ClassLoader）信息统计
-compiler //JIT即时编译器相关的统计信息
-gc // GC相关的堆内存信息。用法：jstat -gc -h 10 -t 864 1s 20
-gccapacity // 各个内存池分代空间的容量
-gccause // 看上次GC，本次GC（如果正在GC中）的原因，其他输出和-gcutil选项一致
-gcmetacapacity //meta区大小统计
-gcnew //年轻代的统计信息。（New = Young = Eden + s0 + s1）
-gcnewcapacity // 年轻代空间大小统计
-gcold // 老年代和元数据区的行为统计
-gcoldcapacity // old空间大小统计
-gcutil // GC相关区域的使用率（utilization）统计
-printcompilation // 打印JVM编译统计信息
```



`jstat -gc pid` ` jstat -gc pid 1000 10`（每秒钟输出一次，输出10次)

![](.README_images/b1d8fba9.png)

`S0C、S1C、S0U、S1U`：S0和S1的总量与使用量

`EC、EU`：Eden区总量与使用量

`OC、OU：Old`区总量与使用量

`MC、MU`：Metaspace区总量与使用量

`CCSC、CCSU`：压缩类空间总量与使用量

`YGC、YGCT`：YongGC的次数与时间

`FGC、FGCT`：FullGC的次数与时间

`GCT`：总的GC时间

注：1.数值单位（KB） 2.CCS+M的量就是非堆

`jstat -gcutil pid 1000 1000`
![](.README_images/2b636f0f.png)

注：内存模块对应的数值指的是使用率。例如E对应17.86，表示Eden区的内存使用率为17.86%

## jmap

```
Usage:
    jmap [option] <pid>
        (to connect to running process)
    jmap [option] <executable <core>
        (to connect to a core file)
    jmap [option] [server_id@]<remote server IP or hostname>
        (to connect to remote debug server)

where <option> is one of:
    <none>               to print same info as Solaris pmap
    -heap                to print java heap summary
    -histo[:live]        to print histogram of java object heap; if the "live"
                         suboption is specified, only count live objects
    -clstats             to print class loader statistics
    -finalizerinfo       to print information on objects awaiting finalization
    -dump:<dump-options> to dump java heap in hprof binary format
                         dump-options:
                           live         dump only live objects; if not specified,
                                        all objects in the heap are dumped.
                           format=b     binary format
                           file=<file>  dump heap to <file>
                         Example: jmap -dump:live,format=b,file=heap.bin <pid>
    -F                   force. Use with -dump:<dump-options> <pid> or -histo
                         to force a heap dump or histogram when <pid> does not
                         respond. The "live" suboption is not supported
                         in this mode.
    -h | -help           to print this help message
    -J<flag>             to pass <flag> directly to the runtime system
```





```c#
[root@sf105220 ~]# jmap -heap 31841
Attaching to process ID 31841, please wait...
Debugger attached successfully.
Server compiler detected.
JVM version is 25.111-b14

using thread-local object allocation.
Parallel GC with 4 thread(s)

Heap Configuration:
   MinHeapFreeRatio         = 0
   MaxHeapFreeRatio         = 100
   MaxHeapSize              = 994050048 (948.0MB) // 机器内存3789MB==> 最大堆内存默认设置的是1/4的机器内存
   NewSize                  = 20971520 (20.0MB)   // 当前新生代的内存
   MaxNewSize               = 331350016 (316.0MB) // 最大新生代内存是堆内存的1/3
   OldSize                  = 41943040 (40.0MB)   // 当前老年代的内存，是新生代的2倍
   NewRatio                 = 2 // old区和young区的比例
   SurvivorRatio            = 8 // Eden区和s0/s1的比例 8:1:1
   MetaspaceSize            = 21807104 (20.796875MB)
   CompressedClassSpaceSize = 1073741824 (1024.0MB)
   MaxMetaspaceSize         = 17592186044415 MB
   G1HeapRegionSize         = 0 (0.0MB)

Heap Usage:
PS Young Generation
Eden Space:
   capacity = 23068672 (22.0MB)
   used     = 5732128 (5.466583251953125MB)
   free     = 17336544 (16.533416748046875MB)
   24.848105690696023% used
From Space:
   capacity = 524288 (0.5MB)
   used     = 65536 (0.0625MB)
   free     = 458752 (0.4375MB)
   12.5% used
To Space:
   capacity = 524288 (0.5MB)
   used     = 0 (0.0MB)
   free     = 524288 (0.5MB)
   0.0% used
PS Old Generation
   capacity = 28311552 (27.0MB)
   used     = 12197832 (11.632759094238281MB)
   free     = 16113720 (15.367240905761719MB)
   43.08429294162326% used

12891 interned Strings occupying 1093296 bytes.
```

内存溢出自动导出内存信息

```
-XX:+HeapDumpOnOutOfMemoryError
-XX:HeapDumpPath=./
```



使用jmap命令手动导出内存信息

`jmap -dump:format=b,file=heap.hprof pid`

需要导入到MAT工具中进行分析



## jstack



    -F  强制执行thread dump。可在java进程卡死（hung住）时使用，此选项可能需要系统权限
    -m  混合模式（mixed mode），将java帧和native帧一起输出，此选项可能需要系统权限。
    -l  长列表模式。将线程相关的locks信息一起输出，比如持有的锁，等待的锁。
使用示例：`jstack pid -l`



## jcmd

jcmd综合了前面的几个命令

示例：

jcmd pid VM.version

jcmd pid VM.flags

jcmd pid VM.command_line

jcmd pid VM.system_properties

jcmd pid Thread.print

jcmd pid GC.class_histogram

jcmd pid GC.heap_info



```
[root@sf105220 ~]# jcmd 31841 help
31841:
The following commands are available:
JFR.stop
JFR.start
JFR.dump
JFR.check
VM.native_memory
VM.check_commercial_features
VM.unlock_commercial_features
ManagementAgent.stop
ManagementAgent.start_local
ManagementAgent.start
GC.rotate_log
Thread.print
GC.class_stats
GC.class_histogram
GC.heap_dump
GC.run_finalization
GC.run
VM.uptime
VM.flags
VM.system_properties
VM.command_line
VM.version
help
```



## jrunscript/jjs

当curl命令用:
 jrunscript -e "cat('http://www.baidu.com')" 执行js脚本片段
 jrunscript -e "print('hello,kk.jvm'+1)" 执行js文件
 jrunscript -l js -f /XXX/XXX/test.js



## 基于JVisualVM的可视化监控

### 监控远程Tomcat

修改Catalina.sh

```
JAVA_OPTS=”$JAVA_OPTS
-Dcom.sun.management.jmxremote
-Dcom.sun.management.jmxremote.port=9004
-Dcom.sun.management.jmxremote.authenticate=false
-Dcom.sun.management.jmxremote.ssl=false
-Djava.net.preferIPv4Stack=true
-Djava.rmi.server.hostname=10.110.3.62”
```



### 监控普通的java进程

```
nohup java -Dcom.sun.management.jmxremote -Dcom.sun.management.jmxremote.port=18090 -Dcom.sun.management.jmxremote.authenticate=false -Dcom.sun.management.jmxremote.ssl=false -Djava.net.preferIPv4Stack=true -Djava.rmi.server.hostname=192.168.199.122 -jar jvm_test-0.0.1-SNAPSHOT.jar &
```

### JMC



通过命令行录制JFR
```
# 延时10s启动，监控1分钟
jcmd pid JFR.start delay=10s duration=1m filename=/path/log.jfr
```
jcmd 31945 VM.unlock_commercial_features

jcmd 31945 JFR.start delay=10s duration=1m filename=/u02/tomcat/log.jfr


# 垃圾回收

### 内存溢出与内存泄漏

- 内存溢出，是指程序在申请内存时，没有足够的内存空间供其使用，出现OOM；
- 内存泄漏，是指程序在申请内存后，无法释放已申请的内存空间，一次内存泄漏危害可以忽略，但是内存泄漏堆积后果很严重，无论内存多大，迟早被占用完进而造成内存溢出

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

​	判断对象是否可回收的标准就是它没有被其他对象引用。下面我们来看看有哪些方式判断对象是否被引用。

#### 引用计数

​	记录对象被引用的数量。当被引用的计数为0时表示可以进行对象回收。但是有个缺点：当A、B对象相互引用时。就算没有对象引用A、B这两个对象也无法对着两个对象进行垃圾回收。

优点：执行效率高，程序执行受到影响较小

缺点：无法检测出循环引用的情况，导致内存泄漏

#### 可达性分析算法
![](.README_images/232c7443.png)
GC Root 根对象：肯定不能被垃圾回收器回收的对象。

- Java 虚拟机中的垃圾回收器采用可达性分析探索所欲存活的对象
- 扫描堆中的对象，看是否能沿着GC Root对象为起点的引用链找到该对象，找不到，表示可以回收

概括起来就是，如果一个对象被跟对象直接或者间接的引用，则这个对象不会被垃圾回收。

哪些对象能作为GC Root对象？

使用MemoryAnalyzer.exe来分析。

```java
package com.wenhao.jvm.t2;

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

/**
 * 演示GC Roots
 */
public class Demo2_2 {

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

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

分别在暂停 1和暂停 2抓取内存快照。

```
jmap -dump:format=b,live,file=2.hprof 55820 #带上live参数会在dump时主动发起一次垃圾回收
```
1.hrof
![](.README_images/25d86d99.png)
2.hrof
![](.README_images/6058f4cd.png)
使用MAT查看1.hprof中的GC Roots，查找Thread目录下的main Thread会有ArrayList，使用MAT查看2.hprof中的GC Roots，查找Thread目录下的main Thread中的ArrayList不见了。说明new出来的ArrayList对象在失去list的引用后被垃圾收集器回收了。



可作为GC Root的对象

- 虚拟机栈（栈帧中的本地变量表）中引用的对象。
- 方法区中的常量引用的对象
- 方法区中的类静态属性引用的对象
- 本地方法栈中JNI（Native方法）的引用对象
- Java虚拟机内部的引用，如基本数据类型对应的Class对象，一些常驻的异常对象（比如NullPointException、OutOfMemoryError）等，还有系统类加载器。
- 活跃线程的引用对象



#### 四种引用

强引用
![](.README_images/5df6e91b.png)


实线箭头便是强引用，强引用是指被GC Root直接引用。

A1对象不能被回收，因为它引用了C和B两个GC Root

A2对象软引用了C（间接引用），如果不引用B对象，在垃圾回收的过程中如果内存不够则A2对象会被回收

A3对象弱引用了C，如果不引用B对象，一旦进行垃圾回收，A2对象将被回收。

ByteBuffer去除了B对象的引用被垃圾回收，虚引用会被放入引用队列，从而调用Unsafe.freeMemory方法释放直接内存

如果没有强引用时,A4对象重写了finallize方法终结器引用就会被放入引用队列，由一个优先级较低的线程去查看引用队列终结器引用，进而找到并执行对象finallize方法，调用完成后下次垃圾回收就能将该对象回收。

1. 强引用

- 只有所有GC Roots 对象都不通过【强引用】引用该对象，该对象才能被垃圾回收。

2. 软引用（SoftReference）

- 仅有软引用引用该对象的，在垃圾回收后，**内存仍不足时**会再次触发垃圾回收，回收软引用对象
- 可以配合引用队列来释放软引用自身

3. 弱引用（WeakReference）

- 仅有弱引用引用该对象时，在垃圾回收时，**无论内存是否充足**，都会回收弱引用对象
- 可以配合引用队列释放弱引用自身

4. 虚引用（PhantomReference）

- 必须配合引用队列使用，主要配合ByteBuffer使用，被引用对象回收时，会将虚引用入队，由Reference Handler线程调用虚引用相关方法释放直接内存

5. 终结器引用（FinalReference）

- 无需手动编码，但其内部配合引用队列使用，在垃圾回收时，终结器引用入队（被引用对象暂时没有被回收），再由Finalizer线程通过终结器引用找到被引用对象并调用它的finalize方法，第二次GC时才能回收引用对象。

##### 软引用演示

```java
package com.wenhao.jvm.t2;

import java.io.IOException;
import java.lang.ref.SoftReference;
import java.util.ArrayList;
import java.util.List;

/**
 * 演示软引用
 * -Xmx20m -XX:+PrintGCDetails -verbose:gc
 */
public class Demo2_3 {

    private static final int _4MB = 4 * 1024 * 1024;

    public static void main(String[] args) throws IOException {

        /*// 强引用
        List<byte[]> list = new ArrayList<byte[]>();
        for (int i = 0; i < 5; i++) {
            list.add(new byte[_4MB]);
        }
        System.in.read();*/

        soft();

    }

    public static void soft() {

        List<SoftReference<byte[]>> list = new ArrayList<SoftReference<byte[]>>();
        for (int i = 0; i < 5; i++) {
            SoftReference<byte[]> ref = new SoftReference<>(new byte[_4MB]);
            System.out.println(ref.get());
            list.add(ref);
            System.out.println(list.size());
        }
        System.out.println("循环结束：" + list.size());
        for (SoftReference<byte[]> ref : list) {
            System.out.println(ref.get());
        }
    }
}
```



```C#
[B@7cef4e59
1
[B@64b8f8f4
2
[B@2db0f6b2
3
## 第四次循环几乎用尽了内存，进行了一次GC
[GC (Allocation Failure) [PSYoungGen: 2474K->496K(6144K)] 14762K->13084K(19968K), 0.0024916 secs] [Times: user=0.05 sys=0.00, real=0.00 secs] 
[B@3cd1f1c8
4
[GC (Allocation Failure) --[PSYoungGen: 4817K->4817K(6144K)] 17406K->17406K(19968K), 0.0030396 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[Full GC (Ergonomics) [PSYoungGen: 4817K->4532K(6144K)] [ParOldGen: 12588K->12490K(13824K)] 17406K->17023K(19968K), [Metaspace: 3310K->3310K(1056768K)], 0.0096178 secs] [Times: user=0.06 sys=0.00, real=0.01 secs] 
[GC (Allocation Failure) --[PSYoungGen: 4532K->4532K(6144K)] 17023K->17047K(19968K), 0.0020109 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
 ## 触发软引用的垃圾回收，新生代和老年代的内存都被回收了
[Full GC (Allocation Failure) [PSYoungGen: 4532K->0K(6144K)] [ParOldGen: 12514K->623K(8704K)] 17047K->623K(14848K), [Metaspace: 3310K->3310K(1056768K)], 0.0119786 secs] [Times: user=0.03 sys=0.00, real=0.01 secs] 
[B@3a4afd8d
5
循环结束：5
null
null
null
null
[B@3a4afd8d
Heap
 PSYoungGen      total 6144K, used 4319K [0x00000000ff980000, 0x0000000100000000, 0x0000000100000000)
  eden space 5632K, 76% used [0x00000000ff980000,0x00000000ffdb7c98,0x00000000fff00000)
  from space 512K, 0% used [0x00000000fff00000,0x00000000fff00000,0x00000000fff80000)
  to   space 512K, 0% used [0x00000000fff80000,0x00000000fff80000,0x0000000100000000)
 ParOldGen       total 8704K, used 623K [0x00000000fec00000, 0x00000000ff480000, 0x00000000ff980000)
  object space 8704K, 7% used [0x00000000fec00000,0x00000000fec9be08,0x00000000ff480000)
 Metaspace       used 3321K, capacity 4556K, committed 4864K, reserved 1056768K
  class space    used 355K, capacity 392K, committed 512K, reserved 1048576K
```

##### 软引用配合引用队列演示

```java
package com.wenhao.jvm.t2;

import java.lang.ref.Reference;
import java.lang.ref.ReferenceQueue;
import java.lang.ref.SoftReference;
import java.util.ArrayList;
import java.util.List;

/**
 * 演示软引用，配合引用队列
 */
public class Demo2_4 {

    private static final int _4MB = 4 * 1024 * 1024;

    public static void main(String[] args) {

        List<SoftReference<byte[]>> list = new ArrayList<>();

        // 引用队列
        ReferenceQueue<byte[]> referenceQueue = new ReferenceQueue<>();

        for (int i = 0; i < 5; i++) {
            // 关联了引用队列，当软引用所关联的 byte[] 被回收时，软引用自己会加到referenceQueue
            SoftReference<byte[]> ref = new SoftReference<>(new byte[_4MB], referenceQueue);
            System.out.println(ref.get());
            list.add(ref);
            System.out.println(list.size());
        }

        // 移除无用的软引用对象
        Reference<? extends byte[]> poll = referenceQueue.poll();
        while (poll != null) {
            list.remove(poll);
            poll = referenceQueue.poll();
        }

        for (SoftReference<byte[]> softReference : list) {
            System.out.println(softReference.get());
        }

    }
}
```

##### 弱引用演示

```java
package com.wenhao.jvm.t2;

import java.lang.ref.WeakReference;
import java.util.ArrayList;
import java.util.List;

/**
 * 演示弱引用
 * -Xmx20m -XX:+PrintGCDetails -verbose:gc
 */
public class Demo2_5 {

    private static final int _4MB = 4 * 1024 * 1024;

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



```c#
[B@64b8f8f4 
[B@64b8f8f4 [B@2db0f6b2 
[B@64b8f8f4 [B@2db0f6b2 [B@3cd1f1c8 [GC (Allocation Failure) [PSYoungGen: 2474K->512K(6144K)] 14762K->13060K(19968K), 0.0017541 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 

[B@64b8f8f4 [B@2db0f6b2 [B@3cd1f1c8 [B@3a4afd8d [GC (Allocation Failure) [PSYoungGen: 4833K->496K(6144K)] 17382K->13064K(19968K), 0.0018619 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 

[B@64b8f8f4 [B@2db0f6b2 [B@3cd1f1c8 null [B@1996cd68 循环结束： 5
Heap
 PSYoungGen      total 6144K, used 4758K [0x00000000ff980000, 0x0000000100000000, 0x0000000100000000)
  eden space 5632K, 75% used [0x00000000ff980000,0x00000000ffda9be0,0x00000000fff00000)
  from space 512K, 96% used [0x00000000fff80000,0x00000000ffffc010,0x0000000100000000)
  to   space 512K, 0% used [0x00000000fff00000,0x00000000fff00000,0x00000000fff80000)
 ParOldGen       total 13824K, used 12568K [0x00000000fec00000, 0x00000000ff980000, 0x00000000ff980000)
  object space 13824K, 90% used [0x00000000fec00000,0x00000000ff8462d0,0x00000000ff980000)
 Metaspace       used 3319K, capacity 4556K, committed 4864K, reserved 1056768K
  class space    used 355K, capacity 392K, committed 512K, reserved 1048576K

```



### 垃圾回收算法

#### 标记清除算法（Mark Sweep）

![](.README_images/44478d41.png)

​	标记清除算法，是将垃圾回收分为2个阶段，分别是标记和清除

- 标记（Mark）：把没有被GC Root引用的对象标记为可回收

- 清除（Sweep）：把可回收对象的起始和结束的地址记录下来放到空闲的地址列表里。新建的对象的时候就会到空闲地址列表中找是否有足够大的空间以容纳新对象。

  标记清除算法可以说是最基础的收集算法，因为后续的收集算法大多都是以标记-清除算法为基础，对其缺点进行改进

缺点：容易产生内存碎片，空间不连续导致不能存储“大”对象，这将导致在下次分配较大的对象时无法找到足够大的连续内存而导致再次触发垃圾回收，直到出现OutOfMermory

#### 标记整理算法（Mark Compact）

​	标记整理算法是在标记清除算法的基础上，进行了算法改进。在清理阶段，并不是简单的清理未标记的对象，而是将存活的对象压缩到内存的一端，然后清理边界以外的垃圾，从而解决碎片化的问题。

![](.README_images/81b567d0.png)

优点：没有内存碎片

缺点：由于整理过程中有对象的移动，引用地址也要跟着调整，这些操作都需要时间。所以效率很低一些

#### 复制算法（copy）

​	复制算法需要提供两个内存空间，垃圾回收是，将正在使用的对象复制到另一个内存空间中，然后将原空间清空，交换两个内存的角色，完成垃圾的回收。

![](.README_images/699a3136.png)

优点：没有内存碎片

缺点：有FROM和TO两块区域，内存*2，需要占用双倍的内存空间

### 分代垃圾回收

新产生的对象进入“伊甸园”，当新生代内存不够会触发Minor GC，采用的复制算法。幸存的对象会被放入幸存区To，对象的年龄+1，并交换幸存区位置。后续如果在发生Minor GC 会重复上述流程，若幸存区对象在GC后仍然存活则对象的年龄+1，当对象的年龄超过一定的阈值，这个对象将晋升到老年代。老年代的空间都不足时，会触发Full GC。

- 对象首先分配在伊甸园区域
- 新生代空间不足时，触发Minor GC，在伊甸园和From存活的对象使用copy复制到to中，存活的对象年龄加1并且交互From To
- Minor GC 会引发 stop the world（STW）, 暂停其它用户线程，等垃圾回收结束，用户线程才恢复运行
- 当对象寿命超过阈值时，会晋升到老年代，最大寿命是15（4bit）
- 当老年代空间不足，会先尝试触发Minor GC 如果之后空间仍然不足，那么会触发Full GC，STW的时间更长

#### 相关VM参数

| 含义               | 参数                                                         |
| :----------------- | ------------------------------------------------------------ |
| 堆初始大小         | -Xms                                                         |
| 堆最大大小         | -Xmx 或者 -XX:MaxHeapSize=size                               |
| 新生代大小         | -Xmn 或者 （-XX:NewSize=size + -XX:MaxNewSize=size）         |
| 幸存区比例（动态） | -XX:InitialSurvivorRatio=ratio 和 -XX:+UseAdaptiveSizePolicy（默认8） |
| 幸存区比例         | -XX:SurvivorRatio=ratio （默认8）                            |
| 晋升阈值           | -XX:MaxTenuringThreshold=threshold                           |
| 晋升详情           | -XX:PrintTenuringDistribution                                |
| GC详情             | -XX:PrintGCDetails -verbose:gc                               |
| Full GC 前 MinorGC | -XX:+ScavengeBeforeFullGC                                    |



```java
package com.wenhao.jvm.t2;

import java.util.ArrayList;

public class Demo2_1 {

    private static final int _512KB = 512 * 1024;
    private static final int _1M = 1024 * 1024;
    private static final int _6M = 6 * 1024 * 1024;
    private static final int _7M = 7 * 1024 * 1024;
    private static final int _8M = 8 * 1024 * 1024;

    // -Xms20M -Xmx20M -Xmn10M -XX:+UseSerialGC -XX:+PrintGCDetails -verbose:gc
    public static void main(String[] args) {
        ArrayList<byte[]> list = new ArrayList<>();
        list.add(new byte[_7M]);
//        [GC (Allocation Failure) [DefNew（表示新生代）: 2625K（回收前内存）->712K（回收后内存）(9216K（新生代总内存）), 0.0023115 secs] 2625K（整个堆回收前的内存）->712K（整个堆回收后的内存）(19456K（堆的总内存）), 0.0023941 secs] [Times: user=0.00 sys=0.00, real=0.00 secs]
//        Heap
//        def new generation   total 9216K, used 8290K [0x00000000fec00000, 0x00000000ff600000, 0x00000000ff600000)
//        eden space 8192K,  92% used [0x00000000fec00000, 0x00000000ff366830, 0x00000000ff400000)
//        from space 1024K,  6 9% used [0x00000000ff500000, 0x00000000ff5b2270, 0x00000000ff600000)
//        to   space 1024K,   0% used [0x00000000ff400000, 0x00000000ff400000, 0x00000000ff500000)
//        tenured generation   total 10240K, used 0K [0x00000000ff600000, 0x0000000100000000, 0x0000000100000000)
//        the space 10240K,   0% used [0x00000000ff600000, 0x00000000ff600000, 0x00000000ff600200, 0x0000000100000000)
//        Metaspace       used 3312K, capacity 4556K, committed 4864K, reserved 1056768K
//        class space    used 355K, capacity 392K, committed 512K, reserved 1048576K
        list.add(new byte[_512KB]);
        list.add(new byte[_512KB]);
//        [GC (Allocation Failure) [DefNew: 2625K->712K(9216K), 0.0019962 secs] 2625K->712K(19456K), 0.0020618 secs] [Times: user=0.00 sys=0.00, real=0.00 secs]
//        [GC (Allocation Failure) [DefNew: 8720K->512K(9216K), 0.0092314 secs] 8720K->8319K(19456K), 0.0093104 secs] [Times: user=0.02 sys=0.00, real=0.01 secs]
//        Heap
//        def new generation   total 9216K, used 1106K [0x00000000fec00000, 0x00000000ff600000, 0x00000000ff600000)
//        eden space 8192K,   7% used [0x00000000fec00000, 0x00000000fec94930, 0x00000000ff400000)
//        from space 1024K,  50% used [0x00000000ff400000, 0x00000000ff480048, 0x00000000ff500000)
//        to   space 1024K,   0% used [0x00000000ff500000, 0x00000000ff500000, 0x00000000ff600000)
//        tenured generation   total 10240K, used 7806K [0x00000000ff600000, 0x0000000100000000, 0x0000000100000000)
//        the space 10240K,  76% used [0x00000000ff600000, 0x00000000ffd9fbc8, 0x00000000ffd9fc00, 0x0000000100000000)
//        Metaspace       used 3312K, capacity 4556K, committed 4864K, reserved 1056768K
//        class space    used 355K, capacity 392K, committed 512K, reserved 1048576K
        // 新生代内存不够，进行了两次MinorGC，没等到对象年龄达到阈值，直接把对象晋升到老年代
    }

//    Heap
//    def new generation（新生代）   total 9216K（刨开了交互区用到的1M）, used 2789K [0x00000000fec00000, 0x00000000ff600000, 0x00000000ff600000)
//    eden space 8192K,  34% used [0x00000000fec00000, 0x00000000feeb94e8, 0x00000000ff400000)
//    from space 1024K,   0% used [0x00000000ff400000, 0x00000000ff400000, 0x00000000ff500000)
//    to   space 1024K,   0% used [0x00000000ff500000, 0x00000000ff500000, 0x00000000ff600000)
//    tenured generation（老年代）   total 10240K, used 0K [0x00000000ff600000, 0x0000000100000000, 0x0000000100000000)
//    the space 10240K,   0% used [0x00000000ff600000, 0x00000000ff600000, 0x00000000ff600200, 0x0000000100000000)
//    Metaspace       used 3311K, capacity 4556K, committed 4864K, reserved 1056768K
//    class space    used 355K, capacity 392K, committed 512K, reserved 1048576K
}
```

大对象新生代放不下，老年代有足够的空间。则大对象将直接晋升到老年代

```java
package com.wenhao.jvm.t2;

import java.util.ArrayList;

public class Demo2_1 {

    private static final int _512KB = 512 * 1024;
    private static final int _1M = 1024 * 1024;
    private static final int _6M = 6 * 1024 * 1024;
    private static final int _7M = 7 * 1024 * 1024;
    private static final int _8M = 8 * 1024 * 1024;

    // -Xms20M -Xmx20M -Xmn10M -XX:+UseSerialGC -XX:+PrintGCDetails -verbose:gc
    public static void main(String[] args) {
        ArrayList<byte[]> list = new ArrayList<>();
        list.add(new byte[_8M]);
//        Heap
//        def new generation   total 9216K, used 2789K [0x00000000fec00000, 0x00000000ff600000, 0x00000000ff600000)
//        eden space 8192K,  34% used [0x00000000fec00000, 0x00000000feeb94e8, 0x00000000ff400000)
//        from space 1024K,   0% used [0x00000000ff400000, 0x00000000ff400000, 0x00000000ff500000)
//        to   space 1024K,   0% used [0x00000000ff500000, 0x00000000ff500000, 0x00000000ff600000)
//        tenured generation   total 10240K, used 8192K [0x00000000ff600000, 0x0000000100000000, 0x0000000100000000)
//        the space 10240K,  80% used [0x00000000ff600000, 0x00000000ffe00010, 0x00000000ffe00200, 0x0000000100000000)
//        Metaspace       used 3312K, capacity 4556K, committed 4864K, reserved 1056768K
//        class space    used 355K, capacity 392K, committed 512K, reserved 1048576K
    }
}
```



### 垃圾回收器

串行

- 单线程
- 堆内存较小的时候，适合个人电脑（CPU个数小）

吞吐量优先

- 多线程
- 堆内存较大，多核CPU
- 尽可能缩短单位时间内的STW时间

响应时间优先

- 多线程
- 堆内存较大，多核CPU
- 尽可能缩短单次STW时间

#### 串行（Serial GC）/ ParNewGC

```
-XX:+UseSerialGC=Serial+SerialOld
```

串行GC对年轻代使用mark-copy（标记-复制）算法，对老年代使用mark-sweep-compact（标记-清除-整理）算法。两者都是单线程的垃圾回收器，不能进行并行处理，所以都会触发全线暂停（STW），暂停所有的应用线程。因此这种GC算法不能充分利用多核CPU。不管有多少CPU内核，JVM在垃圾收集时都只能使用单个核心。

#### 并行GC（Parallel GC）

```
-XX:+UseParallelGC ~ -XX:+UseParallelOldGC
-XX:+UseAdaptiveSizePolicy #自适应调整新生代大小
-XX:GCTimeRatio=ratio      #调整吞吐量  1/(1+ratio) 一般设为19. => 表示100分钟允许5分钟用于垃圾回收，达不到这个指标，则会调整堆的大小，一般会调大来减少GC的次数
-XX:MaxGCPauseMillis=ms    #最大GC暂停毫秒，默认200ms，这项与上面一项是冲突的。想要减少这个暂停时间，回收器会试着将堆的大小调小来缩短每次GC的耗时
-XX:ParallelGCThreads=n #指定GC线程数，其默认值为CPU核心数
```

​	年轻代和老年代的垃圾回收都会触发STW事件。

​	在年轻代使用标记-复制（mark-copy）算法，在老年代使用标记-清除-整理（mark-sweep-compact）算法。

并行垃圾收集器适用于多核服务器，主要目标是增加吞吐量，因为对系统资源的有效使用，能达到更高的吞吐量：

- 在GC期间，所有CPU内核都在并行清理垃圾，所以总暂停时间更短
- 在两次GC周期的间隔期，没有GC线程在运行，不会消耗任何系统资源



#### CMS GC

CMS GC（Mostly Concurrent Mark and Sweep Garbage Collector）

```
-XX:+UseConcMarkSweepGC（并发标记清除） ~ -XX:+UseParNewGC ~ SerialOld
-XX:ParallelGCThreads=n ~ -XX:ConcGCThreads=threads  建议设置：threads=n/4
-XX:CMSInitiatingOccupancyFraction=percent # 默认65，这个值越小，CMS垃圾回收触发时间就会越早 
-XX:+CMSScavengeBeforeRemark #重新标记之前对新生代进行一次垃圾回收
```

​	其对年轻代采用并行STW方式的mark-copy（标记-复制）算法，对老年代主要使用并发mark-sweep（标记-清除）算法。

​	CMS GC的设计目标是避免在老年代垃圾收集时出现长时间的卡顿，主要通过两种手段来达成此目标：

1. 不对老年代进行整理，而是使用空闲列表（free-lists）来管理内存空间的回收
2. 在mark-and-sweep（标记-清除）阶段的大部分工作和应用线程一起并发执行。

​    也就是说，在这些阶段并没有明显的应用线程暂停，但值得注意的是，它仍然和应用线程争抢CPU时间。默认情况下，CMS使用的并发线程数等于CPU核心数的**1/4**。

​	如果服务器是多核CPU，并且主要调优目标是降低GC停顿导致的系统延迟，那么使用CMS是个明智的选择。进行老年代的并发回收是，可能伴随着多次年轻代的minor GC。





##### CMS GC的六个阶段

1. Initial Mark（初始标记）

   这个阶段**伴随着STW暂停**。初始标记的目标是标记所有的根对象，包括跟对象直接引用的对象，以及被年轻代中所有存活对象所引用的对象（老年代单独回收）。

2. Concurrent Mark（并发标记）

   此阶段，CMS GC遍历老年代，标记所有的存活对象，从前一阶段Initial Mark找到的根对象开始算起。这一阶段与应用程序同时运行，**不会触发STW**。

3. Concurrent Preclean（并发预清理）

   此阶段同样是与应用线程并发执行的，不需要停止应用线程。因为前一阶段【并发标记】与程序并发运行，可能一些引用关系已经发生改变。如果在并发标记过程中引用关系发生变化，JVM会通过`Card（卡片）`的方式将发生了变化的区域标记为“脏”区，这就是所谓的**卡片标记（Card Marking）**。

4. Final Remark（最终标记）

   最终标记阶段是此次GC事件中的第二次（也是最后一次）**SWT停顿**。本阶段的目标是完成老年代中所有存活对象的标记。因为之前的预清理阶段是并发执行的，有可能GC线程跟不上应用程序的修改速度。所以需要一次STW暂停来处理各种复杂的情况。通常CMS会尝试在年轻代尽可能空的情况下执行Final Remark阶段，以避免连续触发多次STW事件。

5. Concurrent Sweep（并发清除）

   此阶段与应用程序并发执行，不需要STW停顿。JVM在此阶段删除不再使用的对象，并回收他们占用的内存空间。

6. Concurrent Reset（并发重置）

   CMS垃圾收集器在减少停顿时间上做了很多复杂而有用的工作，用于垃圾回收的并发线程执行的同时，并不需要暂停应用线程。当然，CMS也有一些缺点，其中最大的问题就是老年代内存碎片问题（因为不压缩），在某些情况下GC会造成不可预测的暂停时间，特别是堆内存较大的情况下。

![](.README_images/d5f4eb41.png)

MaxNewSize的默认值为`64*4*13/10=332.75MB`（64位的机器就是64M乘以并行核数乘以系数（13/10））

​	

#### G1 GC

定义：Grabage First，意为垃圾优先，哪一块垃圾最多就优先清理它。

- 2004 论文发布
- 2009 JDK 6u14体验
- 2012 JDK 7u4 官方支持
- 2017 JDK 9 默认

适用场景

- 同时注重吞吐量（Throughput）和低延迟（Low latency），默认的暂停目标是200ms
- 超大堆内存，会将堆划分为多个大小相等的Region
- 整体上是标记+整理算法，两个区域之间是复制算法

相关JVM参数

```
-XX:+UseG1GC
-XX:G1HeapRegionSize=size
-XX:MaxGCPauseMillis=time #50 控制每次GC触发的STW事件耗费的时间在50ms以内，默认是200ms
```

​	G1垃圾收集器是在jdk7中正式使用的全新的垃圾收集器，oracle官方计划在jdk9中将G1变成默认的垃圾收集器， 以替代CMS。

JDK9默认G1为垃圾收集器的提案:https://openjdk.java.net/jeps/248 

将CMS标记为丢弃的提案:https://openjdk.java.net/jeps/291

​	G1 GC最主要的设计目标是：将STW停顿的时间和分布，变成可预期且可配置的。事实上，G1 GC是一款软实时垃圾收集器，可以为其设置某项特定的性能指标。为了达成可预期停顿时间的指标，G1 GC有一些独特的实现。

​	首先，堆不再分为年轻代和老年代，而是划分为多个（通常是2048个）可以存放对象的小堆块区域（smaller heap regions）。每个小块，可能一会被定义成Eden区，一会被指定为Survivor区或者Eden区，一会被指定为Survivor区或者Old区。在逻辑上，所有的Eden区和Survivor区合起来就是年轻代，所有的Old区拼接在一起就是老年代。这样划分之后，使得G1不必每次都去收集整个堆空间，而是以增量的方式来进行处理：每次只能处理一部分内存块，称为此次**GC的回收集**（Collection set）。每次GC暂停都会回收所有年轻代的内存块，但是一般只包含部分老年代的内存块。G1的另一项创新时，在并发阶段估算每个小堆块存活对象的总数。构建回收集的原则是：垃圾最多的小块会被优先收集。这也是G1名称的由来。

##### G1 GC处理步骤

1. 年轻代模式转移暂停（Evacuation Pause）

   G1 GC会通过前面一段时间的运行情况来不断的调整自己的回收策略和行为，以此来比较稳定地控制暂停时间。在应用程序刚启动时，G1还没采集到足够的信息，此时就会处于初始的fully-young模式。当年轻代空间用满后，应用线程会被暂停，年轻代内存中的存活对象被拷贝到存活区。如果还没有存活区，则任意选择一部分空闲的内存块作为存活区。

   拷贝的过程称为转移（Evacuation），这和前面介绍的其他年轻代收集器时一样的工作原理。

2. 并发标记（Concurrent Marking）

   G1 GC的很多概念建立在CMS的基础上。G1并发标记的过程与CMS基本上一样。G1的并发标记通过Snapshot-At-The-Beginning（起始快照）的方式，在标记阶段开始记下所有的存活对象。即时在标记的同时又有一些变成了垃圾。通过对象的存活信息，可以构建出每个堆块的存活状态，以便回收器能高效地进行选择。这些信息会是执行老年代垃圾回收的基石。

3. 转移暂停：混合模式（Evacuation Pause（mixed））

   并发标记完成后，G1将执行一次混合收集（mixed collection），不只是清理年轻代，还将一部分老年代区域也加入到回收集中。混合模式的转移暂停不一定紧跟并发标记阶段。有很多规则和历史数据会影响混合模式的启动时机。比如，在老年代中可以并发地腾出很多小堆块，就没有必要启动混合模式。

   因此，在并发标记和混合转移暂停之间，很可能会存在多次young模式的转移暂停。具体添加到回收集的老年代小堆块的大小以及顺序也是基于许多规则来判定的。其中包括指定的软实时性，存活性，以及在并发标记期间收集的GC效率等数据，外加一些可配置的JVM选项。混合收集的过程，很多程度上和前面的fully-young gc是一样的。

   

特别需要注意的是，在某些情况下G1出发了Full GC，垃圾回收机制有可能退化为Serial GC来完成垃圾回收。这时仅使用单线程完成GC工作，GC暂停时间将达到秒级别！导致这中情况有以下三种可能：

- 并发模式失败

  G1启动标记周期，但是Mix GC之前，老年代就被填满，这时G1会放弃标记周期。

  解决办法：

  增加堆大小

- 晋升失败

  没有足够的内存供存活对象或晋升对象使用，由此触发了Full GC（to-space exhausted/to-space overflow）

  解决办法：

  - 增加 `-XX:G1ReservePercent` 选项的值（并相应增加总的堆大小）增加预留内存量
  - 通过减少 `-XX:InitiatingHeapOccupancyPercent` 提前启动标记周期
  - 也可以通过增加 `-XX:ConcGCThreads` 选项的值增加并行标记线程的数目

- 巨型对象分配失败

  当巨型对象找不到合适的空间进行分配时，就会启动Full GC，来释放空间。

  解决办法：

  增加内存或者增大`-XX:G1HeapRegionSize`

##### G1 GC相关参数

- `-XX:+UseG1GC` => 启动G1 GC
- `-XX:G1NewSizePercent`：初始化年轻代占整个Java Heap的大小，默认值为5%
- `-XX:G1MaxNewSizePercent`：最大年轻代占整个Java Heap的大小，默认值为60%
- `-XX:G1HeapRegionSize`：设置每个Region的大小，单位MB，需要为1，2，4，8，16，32中的某个值，默认是堆内存的1/2000。如果这个值设置比较大，那么大对象就可以进入Region了。
- `-XX:ConcGCThreads`：与java应用一起执行GC线程数量，默认是Java线程的1/4，减少这个参数的数值可能会提升并行回收的效率，提高系统内部的吞吐量。如果这个数值过低，参与回收垃圾的线程不足，也会导致并行回收机制耗时加长。一般将它设置为垃圾回收线程数（ParallelGCThreads）的1/4左右。
- `-XX:+InitiatingHeapOccupancyPercent(简称IHOP)`：G1内部并行回收循环启动的阈值，默认为Java Heap的45%。这个可以理解为老年代使用大于等于45%的时候，JVM会启动垃圾回收。这个值非常重要，它决定了在什么时间启动老年代的并行回收。
- `-XX:G1HeapWastePercent`：G1停止收回的最小内存大小，默认是堆大小的5%。GC会收集所有的Region中的对象，但是如果下降到了5%，就会停下来不再收集了。就是说，不必每次回收就把所有的垃圾都处理完，可以遗留少量下次处理，这样也降低了单次消耗的时间。
- -XX:G1MixedGCCountTarget：设置并行循环之后需要有多少个混合GC启动，默认值是8个。老年代Regions的回收通常比年轻代的收集时间要长一些。所以如果混合收集器比较多，可以允许G1延长老年代的收集时间。
- -XX:+G1PrintRegionLivenessInfo：这个参数需要和-XX:+UnlockDiagnosticVMOptions配合启动，打印JVM的调试信息，每个Region里的对象存活信息。
- -XX:G1ReservePercent：G1位了保留一些空间用于年代之间的提升，默认值是堆空间的10%。因为大量执行回收的地方在年轻代（存活时间较短），所以如果你的应用里面有比较大的堆内存空间、比较多的大对象存活，这里需要保留一些内存。
- -XX:+G1SummarizeRSetStats：这也是一个VM的调试信息，如果启用，会在VM退出的时候打印出Rsets的详细总结信息。如果启用-XX:G1SummaryRSetStatsPeriod参数，就会阶段性地打印Rsets信息。
- -XX:+G1TraceConcRefinement：这个也是一个VM的调试信息，如果启用，并行回收阶段的日志就会详细打印出来。
- `-XX:+GCTimeRatio`：这个参数就是计算花费在java应用线程上和花费在GC线程上的时间比率，默认是9，跟新生代内存的分配比例一致。这个参数主要的目的是让用户可以控制在应用上的时间，G1的计算公式是100/（1+GCTimeRatio）。这样，如果参数设置为9，则最多10%的时间会花费在GC工作上面。Parallel GC的默认值是99，表示1%的时间被用在GC上面，这是因为Parallel GC贯穿整个GC，而G1则根据Region来进行划分，不需要全局性扫描整个堆内存。
- -XX:+UseStringDeduplication：手动开启Java String对象的去重工作，这个是JDK8u20版本之后新增的参数，主要用于相同String避免重复申请内存，节约Region的使用。
- `-XX:MaxGCPauseMills`：预期G1每次执行GC操作的暂停时间，单位是ms，默认是200ms，G1会尽量保证控制在这个范围内。

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

| 收集器            | 串行、并发、并行 | 新生代、老年代 | 算法               | 目标         | 试用场景                                  |
| ----------------- | ---------------- | -------------- | ------------------ | ------------ | ----------------------------------------- |
| Serial            | 串行             | 新生代         | 复制算法           | 响应速度优先 | 单CPU环境下的Client模式                   |
| Serial Old        | 串行             | 老年代         | 标记-整理          |              | 单CPU环境下的Client模式，CMS的后备预案    |
| ParNew            | 并行             | 新生代         | 复制算法           |              | 多CPU环境时在Server模式下与CMS配合        |
| Parallel Scavenge | 并行             | 新生代         | 复制算法           | 吞吐量优先   | 在后台运行而不需要太多交互的任务          |
| Parallel Old      | 并行             | 老年代         | 标记-整理          | 吞吐量优先   | 在后台运算而不需要太多交互的任务          |
| CMS               | 并发             | 老年代         | 标记-清除          | 响应速度优先 | 集中在互联网站或B/S系统服务端上的Java应用 |
| G1                | 并发             | Both           | 标记-整理+复制算法 | 响应速度优先 | 面向服务端应用，将来替换CMS               |



#### GC组合

![](.README_images/06f75482.png)

#### GC如何选择

​	选择正确的GC算法，唯一可行的方式就是去尝试，一般性的指导原则：

- 如果系统考虑吞吐优先，CPU资源都采用最大程度处理业务，用Parallel GC；
- 如果系统考虑低延迟，每次GC时间尽量短，用CMS GC；
- 如果系统内存堆较大，同时希望整体来看平均GC时间可控，使用G1 GC；

对于内存大小的考量：

- 一般4G以上，算是比较大，用G1的性价比较高；
- 一般超过8G，比如16-64G内存，非常推荐使用G1 GC；



#### ZGC

-XX:+UnlockExperimentalVMOptions -XX:+UseZGC -Xmx16g

ZGC 最主要的特点包括:

1. GC最大停顿时间不超过10ms

2. 堆内存支持范围广，小至几百MB的堆空间，大至4TB的超大堆 内存(JDK13 升至 16TB)

3. 与G1相比，应用吞吐量下降不超过15%

4. 当前只支持Linux/x64位平台，JDK15后支持MacOS和 Windows 系统



### 分析调优

#### 堆内存的大小对垃圾回收的影响



```
package com.wenhao.gc;

import java.util.Random;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.LongAdder;

/**
 * GC日志生成
 */
public class GCLogAnalysis {
    private static Random random = new Random();
    public static void main(String[] args) {
        long startMillis = System.currentTimeMillis();
        // 持续运行毫秒数
        long timeoutMillis = TimeUnit.SECONDS.toMillis(1);
        // 结束时间戳
        long endMillis = startMillis + timeoutMillis;
        LongAdder counter = new LongAdder();
        System.out.println("正在执行...");
        // 缓存一部分对象进入老年代
        int cacheSize = 2000;
        Object[] cachedGarbage = new Object[cacheSize];
        // 在此时间段中循环执行
        while (System.currentTimeMillis() < endMillis) {
            // 生成垃圾对象
            Object garbage = generateGarbage(100*1024);
            counter.increment();
            int randomIndex = random.nextInt(2 * cacheSize);
            if (randomIndex < cacheSize) {
                // 对象的引用会被覆盖，产生垃圾
                cachedGarbage[randomIndex] = garbage;
            }
        }
        System.out.println("执行结束，共生成对象次数:" + counter.longValue());
    }

    // 生成对象
    private static Object generateGarbage(int max) {
        int randomSize = random.nextInt(max);
        int type = randomSize % 4;
        Object result = null;
        switch (type) {
            case 0:
                result = new int[randomSize];
                break;
            case 1:
                result = new byte[randomSize];
                break;
            case 2:
                result = new double[randomSize];
                break;
            default:
                StringBuilder builder = new StringBuilder();
                String randomString = "randomString-Anything";
                while (builder.length() < randomSize) {
                    builder.append(randomString);
                    builder.append(max);
                    builder.append(randomSize);
                }
                result = builder.toString();
                break;
        }
        return result;
    }
}
```



java -XX:+PrintGCDetails GCLogAnalysis

java -Xloggc:gc.demo.log  -XX:+PrintGCDetails -XX:+PrintGCDateStamps GCLogAnalysis

1）模拟OOM，java -Xmx128m -XX:+PrintGCDetails GCLogAnalysis

抛异常前不断的进行Full GC但是效果不明显直到OOM

2）分别使用512m，1024m，2048m，4096m，观察GC信息的差异。

512m并没有OOM但是后期一直Full GC，CPU使用率高达300%，每次GC的耗时160ms左右

1024m young GC和Full GC 6:1，CPU使用率高达220%，每次Full GC的耗时200ms左右，但是次数减少

4096m 垃圾回收频率明显减少，CPU使用率高达180%，每次YoungGC 150ms，左右每次Full GC的耗时220ms左右，但是次数减少

```c#
java -XX:+PrintGCDetails -XX:+PrintGCDateStamps -XX:+UseSerialGC -Xms4g -Xmx4g  GCLogAnalysis
java -XX:+PrintGCDetails -XX:+PrintGCDateStamps -XX:+UseSerialGC -Xms2g -Xmx2g  GCLogAnalysis
java -XX:+PrintGCDetails -XX:+PrintGCDateStamps -XX:+UseSerialGC -Xms1g -Xmx1g  GCLogAnalysis
java -XX:+PrintGCDetails -XX:+PrintGCDateStamps -XX:+UseSerialGC -Xms6g -Xmx6g  GCLogAnalysis  
jmap -heap `jps -mlv|grep GCLogAnalysis | awk '{print $1}'`
// 8G内存默认
Mark Sweep Compact GC

Heap Configuration:
   MinHeapFreeRatio         = 40
   MaxHeapFreeRatio         = 70
   MaxHeapSize              = 2092957696 (1996.0MB)
   NewSize                  = 44040192 (42.0MB)
   MaxNewSize               = 697630720 (665.3125MB)// 1996/665=3
   OldSize                  = 88080384 (84.0MB) // 84/42=2
   NewRatio                 = 2
   SurvivorRatio            = 8
   MetaspaceSize            = 21807104 (20.796875MB)
   CompressedClassSpaceSize = 1073741824 (1024.0MB)
   MaxMetaspaceSize         = 17592186044415 MB
   G1HeapRegionSize         = 0 (0.0MB)

     
Heap Configuration:
   MinHeapFreeRatio         = 40
   MaxHeapFreeRatio         = 70
   MaxHeapSize              = 1073741824 (1024.0MB)
   NewSize                  = 357892096 (341.3125MB)
   MaxNewSize               = 357892096 (341.3125MB) // 1024/341.3125=3
   OldSize                  = 715849728 (682.6875MB) // 682.6875/341.3125=2
   NewRatio                 = 2
   SurvivorRatio            = 8
   MetaspaceSize            = 21807104 (20.796875MB)
   CompressedClassSpaceSize = 1073741824 (1024.0MB)
   MaxMetaspaceSize         = 17592186044415 MB
   G1HeapRegionSize         = 0 (0.0MB)
// 执行结束，共生成对象次数:234638     
    
Mark Sweep Compact GC

Heap Configuration:
   MinHeapFreeRatio         = 40
   MaxHeapFreeRatio         = 70
   MaxHeapSize              = 2147483648 (2048.0MB)
   NewSize                  = 715784192 (682.625MB)
   MaxNewSize               = 715784192 (682.625MB)
   OldSize                  = 1431699456 (1365.375MB)
   NewRatio                 = 2
   SurvivorRatio            = 8
   MetaspaceSize            = 21807104 (20.796875MB)
   CompressedClassSpaceSize = 1073741824 (1024.0MB)
   MaxMetaspaceSize         = 17592186044415 MB
   G1HeapRegionSize         = 0 (0.0MB)
// 执行结束，共生成对象次数:283198
     
Mark Sweep Compact GC

Heap Configuration:
   MinHeapFreeRatio         = 40
   MaxHeapFreeRatio         = 70
   MaxHeapSize              = 4294967296 (4096.0MB)
   NewSize                  = 1431633920 (1365.3125MB)
   MaxNewSize               = 1431633920 (1365.3125MB)
   OldSize                  = 2863333376 (2730.6875MB)
   NewRatio                 = 2
   SurvivorRatio            = 8
   MetaspaceSize            = 21807104 (20.796875MB)
   CompressedClassSpaceSize = 1073741824 (1024.0MB)
   MaxMetaspaceSize         = 17592186044415 MB
   G1HeapRegionSize         = 0 (0.0MB)
// 执行结束，共生成对象次数:283641
     
Mark Sweep Compact GC

Heap Configuration:
   MinHeapFreeRatio         = 40
   MaxHeapFreeRatio         = 70
   MaxHeapSize              = 6442450944 (6144.0MB)
   NewSize                  = 2147483648 (2048.0MB)
   MaxNewSize               = 2147483648 (2048.0MB)
   OldSize                  = 4294967296 (4096.0MB)
   NewRatio                 = 2
   SurvivorRatio            = 8
   MetaspaceSize            = 21807104 (20.796875MB)
   CompressedClassSpaceSize = 1073741824 (1024.0MB)
   MaxMetaspaceSize         = 17592186044415 MB
   G1HeapRegionSize         = 0 (0.0MB)
// 执行结束，共生成对象次数:204262
     
// 结论：最大堆内存=3*最大年轻代；2*年轻代=老年代 ,当内存增大到6G生成的对象数反而减少了说明GC的性能下降了   
```



```c#
java -XX:+PrintGCDetails -XX:+PrintGCDateStamps -XX:+UseParallelGC -Xms1g -Xmx1g  GCLogAnalysis
java -XX:+PrintGCDetails -XX:+PrintGCDateStamps -XX:+UseParallelGC -Xms2g -Xmx2g  GCLogAnalysis
java -XX:+PrintGCDetails -XX:+PrintGCDateStamps -XX:+UseParallelGC -Xms4g -Xmx4g  GCLogAnalysis
java -XX:+PrintGCDetails -XX:+PrintGCDateStamps -XX:+UseParallelGC -Xms6g -Xmx6g  GCLogAnalysis
jmap -heap `jps -mlv|grep GCLogAnalysis | awk '{print $1}'`
  
// 8G内存默认
Parallel GC with 4 thread(s)

Heap Configuration:
   MinHeapFreeRatio         = 0
   MaxHeapFreeRatio         = 100
   MaxHeapSize              = 2092957696 (1996.0MB)
   NewSize                  = 44040192 (42.0MB)
   MaxNewSize               = 697303040 (665.0MB)
   OldSize                  = 88080384 (84.0MB)
   NewRatio                 = 2
   SurvivorRatio            = 8
   MetaspaceSize            = 21807104 (20.796875MB)
   CompressedClassSpaceSize = 1073741824 (1024.0MB)
   MaxMetaspaceSize         = 17592186044415 MB
   G1HeapRegionSize         = 0 (0.0MB)
// 执行结束，共生成对象次数:266789

Parallel GC with 4 thread(s)

Heap Configuration:
   MinHeapFreeRatio         = 0
   MaxHeapFreeRatio         = 100
   MaxHeapSize              = 1073741824 (1024.0MB)
   NewSize                  = 357564416 (341.0MB)
   MaxNewSize               = 357564416 (341.0MB)
   OldSize                  = 716177408 (683.0MB)
   NewRatio                 = 2
   SurvivorRatio            = 8
   MetaspaceSize            = 21807104 (20.796875MB)
   CompressedClassSpaceSize = 1073741824 (1024.0MB)
   MaxMetaspaceSize         = 17592186044415 MB
   G1HeapRegionSize         = 0 (0.0MB)
// 执行结束，共生成对象次数:227750

Parallel GC with 4 thread(s)

Heap Configuration:
   MinHeapFreeRatio         = 0
   MaxHeapFreeRatio         = 100
   MaxHeapSize              = 2147483648 (2048.0MB) // 2048.0/682.5=3
   NewSize                  = 715653120 (682.5MB)
   MaxNewSize               = 715653120 (682.5MB)
   OldSize                  = 1431830528 (1365.5MB)
   NewRatio                 = 2
   SurvivorRatio            = 8
   MetaspaceSize            = 21807104 (20.796875MB)
   CompressedClassSpaceSize = 1073741824 (1024.0MB)
   MaxMetaspaceSize         = 17592186044415 MB
   G1HeapRegionSize         = 0 (0.0MB)
//执行结束，共生成对象次数:273288

Parallel GC with 4 thread(s)

Heap Configuration:
   MinHeapFreeRatio         = 0
   MaxHeapFreeRatio         = 100
   MaxHeapSize              = 4294967296 (4096.0MB)
   NewSize                  = 1431306240 (1365.0MB)
   MaxNewSize               = 1431306240 (1365.0MB)
   OldSize                  = 2863661056 (2731.0MB)
   NewRatio                 = 2
   SurvivorRatio            = 8
   MetaspaceSize            = 21807104 (20.796875MB)
   CompressedClassSpaceSize = 1073741824 (1024.0MB)
   MaxMetaspaceSize         = 17592186044415 MB
   G1HeapRegionSize         = 0 (0.0MB)
// 执行结束，共生成对象次数:296255
Parallel GC with 4 thread(s)

Heap Configuration:
   MinHeapFreeRatio         = 0
   MaxHeapFreeRatio         = 100
   MaxHeapSize              = 6442450944 (6144.0MB)
   NewSize                  = 2147483648 (2048.0MB)
   MaxNewSize               = 2147483648 (2048.0MB)
   OldSize                  = 4294967296 (4096.0MB)
   NewRatio                 = 2
   SurvivorRatio            = 8
   MetaspaceSize            = 21807104 (20.796875MB)
   CompressedClassSpaceSize = 1073741824 (1024.0MB)
   MaxMetaspaceSize         = 17592186044415 MB
   G1HeapRegionSize         = 0 (0.0MB)
// 执行结束，共生成对象次数:341280
// 结论：最大堆内存=3*最大年轻代；2*年轻代=老年代
```





```c#

java -XX:+PrintGCDetails -XX:+PrintGCDateStamps -XX:+UseConcMarkSweepGC GCLogAnalysis
java -XX:+PrintGCDetails -XX:+PrintGCDateStamps -XX:+UseConcMarkSweepGC -Xms1g -Xmx1g  GCLogAnalysis
java -XX:+PrintGCDetails -XX:+PrintGCDateStamps -XX:+UseConcMarkSweepGC -Xms2g -Xmx2g  GCLogAnalysis
java -XX:+PrintGCDetails -XX:+PrintGCDateStamps -XX:+UseConcMarkSweepGC -Xms4g -Xmx4g  GCLogAnalysis
java -XX:+PrintGCDetails -XX:+PrintGCDateStamps -XX:+UseConcMarkSweepGC -Xms6g -Xmx6g  GCLogAnalysis

jmap -heap `jps -mlv|grep GCLogAnalysis | awk '{print $1}'`

Heap Configuration:
   MinHeapFreeRatio         = 40
   MaxHeapFreeRatio         = 70
   MaxHeapSize              = 2092957696 (1996.0MB)
   NewSize                  = 44040192 (42.0MB)
   MaxNewSize               = 348913664 (332.75MB) // 1996/332.75=6
   OldSize                  = 88080384 (84.0MB) // 84/42=2
   NewRatio                 = 2
   SurvivorRatio            = 8
   MetaspaceSize            = 21807104 (20.796875MB)
   CompressedClassSpaceSize = 1073741824 (1024.0MB)
   MaxMetaspaceSize         = 17592186044415 MB
   G1HeapRegionSize         = 0 (0.0MB)
// 执行结束，共生成对象次数:289964
// -Xmx1g 
Concurrent Mark-Sweep GC

Heap Configuration:
   MinHeapFreeRatio         = 40
   MaxHeapFreeRatio         = 70
   MaxHeapSize              = 1073741824 (1024.0MB)
   NewSize                  = 348913664 (332.75MB)
   MaxNewSize               = 348913664 (332.75MB) // 1024/332.75=3
   OldSize                  = 724828160 (691.25MB) // 691.25/332.75=2
   NewRatio                 = 2
   SurvivorRatio            = 8
   MetaspaceSize            = 21807104 (20.796875MB)
   CompressedClassSpaceSize = 1073741824 (1024.0MB)
   MaxMetaspaceSize         = 17592186044415 MB
   G1HeapRegionSize         = 0 (0.0MB)
// 执行结束，共生成对象次数:293891
// -Xmx2g 
Concurrent Mark-Sweep GC

Heap Configuration:
   MinHeapFreeRatio         = 40
   MaxHeapFreeRatio         = 70
   MaxHeapSize              = 2147483648 (2048.0MB)
   NewSize                  = 348913664 (332.75MB)
   MaxNewSize               = 348913664 (332.75MB)
   OldSize                  = 1798569984 (1715.25MB) // 2048/1715.25=1.19
   NewRatio                 = 2
   SurvivorRatio            = 8
   MetaspaceSize            = 21807104 (20.796875MB)
   CompressedClassSpaceSize = 1073741824 (1024.0MB)
   MaxMetaspaceSize         = 17592186044415 MB
   G1HeapRegionSize         = 0 (0.0MB)
// 执行结束，共生成对象次数:281344
// -Xmx4g
Concurrent Mark-Sweep GC

Heap Configuration:
   MinHeapFreeRatio         = 40
   MaxHeapFreeRatio         = 70
   MaxHeapSize              = 4294967296 (4096.0MB)
   NewSize                  = 348913664 (332.75MB)
   MaxNewSize               = 348913664 (332.75MB)
   OldSize                  = 3946053632 (3763.25MB)
   NewRatio                 = 2
   SurvivorRatio            = 8
   MetaspaceSize            = 21807104 (20.796875MB)
   CompressedClassSpaceSize = 1073741824 (1024.0MB)
   MaxMetaspaceSize         = 17592186044415 MB
   G1HeapRegionSize         = 0 (0.0MB)
// 执行结束，共生成对象次数:285568  

Heap Configuration:
   MinHeapFreeRatio         = 40
   MaxHeapFreeRatio         = 70
   MaxHeapSize              = 6442450944 (6144.0MB)
   NewSize                  = 348913664 (332.75MB)
   MaxNewSize               = 348913664 (332.75MB)
   OldSize                  = 6093537280 (5811.25MB)
   NewRatio                 = 2
   SurvivorRatio            = 8
   MetaspaceSize            = 21807104 (20.796875MB)
   CompressedClassSpaceSize = 1073741824 (1024.0MB)
   MaxMetaspaceSize         = 17592186044415 MB
   G1HeapRegionSize         = 0 (0.0MB)
// 执行结束，共生成对象次数:271051 Young GC延迟变高 每次90ms左右
// // -Xmx512m 
Concurrent Mark-Sweep GC

Heap Configuration:
   MinHeapFreeRatio         = 40
   MaxHeapFreeRatio         = 70
   MaxHeapSize              = 536870912 (512.0MB)
   NewSize                  = 178913280 (170.625MB)
   MaxNewSize               = 178913280 (170.625MB) // 512/170.625=3
   OldSize                  = 357957632 (341.375MB) // 341.375/170.625=2
   NewRatio                 = 2
   SurvivorRatio            = 8
   MetaspaceSize            = 21807104 (20.796875MB)
   CompressedClassSpaceSize = 1073741824 (1024.0MB)
   MaxMetaspaceSize         = 17592186044415 MB
   G1HeapRegionSize         = 0 (0.0MB)

// MaxNewSize的默认值为`64*4*13/10=332.75MB`（64位的机器就是64M乘以并行核数乘以系数（13/10））
```



```c#
java -XX:+PrintGCDetails -XX:+PrintGCDateStamps -XX:+UseG1GC GCLogAnalysis
java -XX:+PrintGCDetails -XX:+PrintGCDateStamps -XX:+UseG1GC -Xms1g -Xmx1g  GCLogAnalysis
java -XX:+PrintGCDetails -XX:+PrintGCDateStamps -XX:+UseG1GC -Xms2g -Xmx2g  GCLogAnalysis
java -XX:+PrintGCDetails -XX:+PrintGCDateStamps -XX:+UseG1GC -Xms4g -Xmx4g  GCLogAnalysis
java -XX:+PrintGCDetails -XX:+PrintGCDateStamps -XX:+UseG1GC -Xms6g -Xmx6g  GCLogAnalysis


jmap -heap `jps -mlv|grep GCLogAnalysis | awk '{print $1}'`

// 8G内存默认
Garbage-First (G1) GC with 4 thread(s)

Heap Configuration:
   MinHeapFreeRatio         = 40
   MaxHeapFreeRatio         = 70
   MaxHeapSize              = 2092957696 (1996.0MB) // 7982/4=1996
   NewSize                  = 1363144 (1.2999954223632812MB) 
   MaxNewSize               = 1255145472 (1197.0MB) // 1996/1197=1.667
   OldSize                  = 5452592 (5.1999969482421875MB) // 5452592/1363144=4
   NewRatio                 = 2
   SurvivorRatio            = 8
   MetaspaceSize            = 21807104 (20.796875MB)
   CompressedClassSpaceSize = 1073741824 (1024.0MB)
   MaxMetaspaceSize         = 17592186044415 MB
   G1HeapRegionSize         = 1048576 (1.0MB)
// 执行结束，共生成对象次数:330105

Garbage-First (G1) GC with 4 thread(s)

Heap Configuration:
   MinHeapFreeRatio         = 40
   MaxHeapFreeRatio         = 70
   MaxHeapSize              = 1073741824 (1024.0MB)
   NewSize                  = 1363144 (1.2999954223632812MB)
   MaxNewSize               = 643825664 (614.0MB)
   OldSize                  = 5452592 (5.1999969482421875MB)
   NewRatio                 = 2
   SurvivorRatio            = 8
   MetaspaceSize            = 21807104 (20.796875MB)
   CompressedClassSpaceSize = 1073741824 (1024.0MB)
   MaxMetaspaceSize         = 17592186044415 MB
   G1HeapRegionSize         = 1048576 (1.0MB)
// 执行结束，共生成对象次数:260062
Garbage-First (G1) GC with 4 thread(s)

Heap Configuration:
   MinHeapFreeRatio         = 40
   MaxHeapFreeRatio         = 70
   MaxHeapSize              = 2147483648 (2048.0MB)
   NewSize                  = 1363144 (1.2999954223632812MB)
   MaxNewSize               = 1287651328 (1228.0MB)
   OldSize                  = 5452592 (5.1999969482421875MB)
   NewRatio                 = 2
   SurvivorRatio            = 8
   MetaspaceSize            = 21807104 (20.796875MB)
   CompressedClassSpaceSize = 1073741824 (1024.0MB)
   MaxMetaspaceSize         = 17592186044415 MB
   G1HeapRegionSize         = 1048576 (1.0MB)     
// 执行结束，共生成对象次数:299045
Garbage-First (G1) GC with 4 thread(s)

Heap Configuration:
   MinHeapFreeRatio         = 40
   MaxHeapFreeRatio         = 70
   MaxHeapSize              = 4294967296 (4096.0MB)
   NewSize                  = 1363144 (1.2999954223632812MB)
   MaxNewSize               = 2575302656 (2456.0MB) // 4096/2456
   OldSize                  = 5452592 (5.1999969482421875MB)
   NewRatio                 = 2
   SurvivorRatio            = 8
   MetaspaceSize            = 21807104 (20.796875MB)
   CompressedClassSpaceSize = 1073741824 (1024.0MB)
   MaxMetaspaceSize         = 17592186044415 MB
   G1HeapRegionSize         = 2097152 (2.0MB)
// 执行结束，共生成对象次数:363411
Garbage-First (G1) GC with 4 thread(s)

Heap Configuration:
   MinHeapFreeRatio         = 40
   MaxHeapFreeRatio         = 70
   MaxHeapSize              = 6442450944 (6144.0MB)
   NewSize                  = 1363144 (1.2999954223632812MB)
   MaxNewSize               = 3865051136 (3686.0MB)
   OldSize                  = 5452592 (5.1999969482421875MB)
   NewRatio                 = 2
   SurvivorRatio            = 8
   MetaspaceSize            = 21807104 (20.796875MB)
   CompressedClassSpaceSize = 1073741824 (1024.0MB)
   MaxMetaspaceSize         = 17592186044415 MB
   G1HeapRegionSize         = 2097152 (2.0MB)
// 执行结束，共生成对象次数:370667
// -Xmx512m 
Garbage-First (G1) GC with 4 thread(s)

Heap Configuration:
   MinHeapFreeRatio         = 40
   MaxHeapFreeRatio         = 70
   MaxHeapSize              = 536870912 (512.0MB)
   NewSize                  = 1363144 (1.2999954223632812MB)
   MaxNewSize               = 321912832 (307.0MB) // 512/307=1.667
   OldSize                  = 5452592 (5.1999969482421875MB)
   NewRatio                 = 2
   SurvivorRatio            = 8
   MetaspaceSize            = 21807104 (20.796875MB)
   CompressedClassSpaceSize = 1073741824 (1024.0MB)
   MaxMetaspaceSize         = 17592186044415 MB
   G1HeapRegionSize         = 1048576 (1.0MB)
```



| Heap Size | Serial GC | Parallel GC | CMC GC | G1 GC  |
| --------- | --------- | ----------- | ------ | ------ |
| 1G        | 234638    | 227750      | 289964 | 260062 |
| 2G        | 283198    | 273288      | 281344 | 299045 |
| 4G        | 283641    | 296255      | 285568 | 363411 |
| 6G        | 204262    | 341280      | 271051 | 370667 |


#### 不同垃圾收集器的效率

java -Xms512m -Xmx512m -XX:+PrintGCDetails +XX:+UseSerialGC GCLogAnalysis # 15774

与PS相比相同时间产生的对象数明显降低了。

java -Xms512m -Xmx512m -XX:+PrintGCDetails +XX:+UseSerialGC GCLogAnalysis # 19513

java -Xms512m -Xmx512m -XX:+PrintGCDetails +XX:+UseConcMarkSweepGC GCLogAnalysis # 21654



# JVM对高效并发的支持

## JMM

# JVM常见面试题

## 什么是JVM

JVM全称是`Java Virtual Machine`，中文称为Java虚拟机。

JVM是Java程序运行的底层平台，与Java支持库一起构成了Java程序的执行环境。分为JVM规范和JVM实现两部分。简单来说，Java虚拟机就是指能执行标准Java字节码的虚拟机。

### 请问JDK与JVM有什么区别

现在的JDK、JRE和JVM一般是整套出现的。

 JDK = JRE + 开发调试诊断工具
 JRE = JVM + Java标准库

### 你认识哪些JVM厂商

常见的JDK厂商包括:

- Oracle公司，包括 Hotspot虚拟机、GraalVM;分为OpenJDK和OracleJDK两种 版本。

- IBM 公司，J9虚拟机， 用在IBM的产品套件中
-  Azul Systems公司，高性能的Zing和开源的Zulu 
- 阿里巴巴，Dragonwell 是阿里开发的OpenJDK定制版 
- 亚马逊，Corretto OpenJDK
-  Red Hat公司的OpenJDK
-  Adopt OpenJDK 
- 此外，还有一些开源和试验性质的JVM实现，比如Go.JVM

### OracleJDK与OpenJDK有什么区别

各种版本的JDK一般来说都会符合Java虚拟机规范。

两者的区别一般来说包括:

- 两种JDK提供的工具套件略有差别，比如jmc等有版权的工具。 
- 某些协议或配置不一样，比如美国限制出口的加密算法。 
- 其他细微差别，比如JRE中某些私有的API不一样。

### 开发中使用哪个版本的JDK?生产环境呢? 为什么这么选?

选择哪个版本需要考虑研发团队的具体情况:比如机器的操作系统，团队 成员的掌握情况，兼顾遗留项目等等。 当前Java最受欢迎的长期维护版本是Java8和Java11。

- Java8是经典LTS版本，性能优秀，系统稳定，良好支持各种CPU架构和操作系统平台。

- Java11是新的长期支持版，性能更强，支持更多新特性，而且经过几年的维护已经很稳定

## 什么是Java字节码

Java中的字节码，是指Java源代码编译后的中间代码格式，一般称为字节码文件。

### 字节码文件中包含哪些内容

字节码文件中，一般包含以下部分：

- 版本号信息
- 静态常量池（付哈常量）
- 类相关的信息
- 字段相关的信息
- 方法相关的信息
- 调试相关的信息

可以说，大部分信息都是通过常量池中的符号常量来表述的。

### 什么是常量

常量是指不变的量，比如字母`'A'`或者数字`2048`在UTF-8编码中对应的二进制格式都是不变的。同样的，字符串在Java中的二进制表示也是不变的，比如`"KK"`。在Java中需要注意的是，`final`关键词修饰的字段和变量，表示最终变量，只能赋值一次，不允许再次修改，由编译器和执行引擎共同保证。

### 你怎么理解常量池

在Java中，常量池包含两层含义：

- 静态常量池，class文件中的一部分，里面保存的是类相关的各种符号常量。
- 运行时常量池，其内容主要由静态常量池解析得到，但是可以由程序添加。

## JVM的运行时数据区有哪些？

根据JVM规范，标准的JVM运行时数据区包括以下部分：

- 程序计数器
- Java虚拟机栈
- 堆内存
- 方法区
- 运行时常量池
- 本地方法栈

### 什么是堆内存

堆内存是指有程序代码自由分配的内存，与栈内存作区分。在Java中，堆内存主要用于分配对象的存储空间，只要拿到对象引用，所有线程都可以访问堆内存。

### 堆内存包括哪些部分

以Hotspot为例，堆内存（Heap）主要由GC模块进行分配和管理，可以分为以下部分：

- 新生代
- 存活区
- 老年代

其中新生代和存活区一般称为年轻代。

### 什么是非堆内存

除堆内存之外，JVM的内存池还包括非堆（NON_HEAP），对应于JVM规范中的方法区，常量池等部分：

- MetaSpace
- CodeCache
- Compressed Class Space

## 什么是内存溢出

内存溢出（OOM）是指可用内存不足。

程序运行需要使用的内存超出最大可用值，如果不进行处理就会影响到其他进程，所以现在操作系统的处理办法就是：只要超出就立即报错，比如抛出内存溢出错误。

### 什么是内存泄漏

内存泄漏（Memory Leak）是指本来无用的对象却继续占用内存，没有再恰当的时机释放占用的内存。

## 两者的关系

如果存在严重的内存泄露问题，随着时间的推移，则必然会引用内存溢出。

内存泄漏一般是资源管理问题和程序BUG，内存溢出则是内存空间不足和内存泄漏的最终结果。

## 给定一个具体的类，请分析对象的内存占用

```java
public class MyOrder {
	private long orderId;
	private long userId;
	private byte state;
	private long createMillis;
}
```

结论：MyOrder类的每个对象会占用40个字节

### 怎么计算

计算方式：

- 对象头占用12字节。
- 每个long类型的字段占用8字节，3*8=24字节
- byte字段占用1字节
- 以上合计37字节，再加上要以8字节为基数补齐，则实际占用40个字节

### 对象头包含哪些部分

对象头中一般包含两个部分：

- 标记字，占用一个机器字，也就是8字节。
- 类型指针，占用一个机器字，也就是8个字节。如果堆内存小于32G，JVM默认会开启指针压缩，则只占用4个字节。

所以前面的计算中，对象头占用12字节。

如果是数组，对象头中还会多出一部分：

- 数组长度，int值，占用4字节。

## 常用的JVM启动参数有哪些

截止目前(2020年3月)，JVM可配置参数已经达到1000多个，其中GC和内存配置相 关的JVM参数就有600多个。 但在绝大部分业务场景下，常用的JVM配置参数也就10来个。

例如：

```apl
# JVM启动参数不换行
# 设置堆内存
‐Xmx4g ‐Xms4g
# 指定GC算法
‐XX:+UseG1GC ‐XX:MaxGCPauseMillis=50 # 指定GC并行线程数 ‐XX:ParallelGCThreads=4
# 打印GC日志
‐XX:+PrintGCDetails ‐XX:+PrintGCDateStamps # 指定GC日志文件
‐Xloggc:gc.log
# 指定Meta区的最大值 ‐XX:MaxMetaspaceSize=2g
# 设置单个线程栈的大小
‐Xss1m
# 指定堆内存溢出时自动进行Dump ‐XX:+HeapDumpOnOutOfMemoryError ‐XX:HeapDumpPath=/usr/local/
```

此外，还有一些常用的属性配置：

```apl
# 指定默认的连接超时时间 
‐Dsun.net.client.defaultConnectTimeout=2000
‐Dsun.net.client.defaultReadTimeout=2000
# 指定时区
‐Duser.timezone=GMT+08
# 设置默认的文件编码为UTF‐8 ‐Dfile.encoding=UTF‐8
# 指定随机数熵源(Entropy Source) ‐Djava.security.egd=file:/dev/./urandom
```

### 设置堆内存Xmx应该考虑哪些因素

需要根据系统的配置来确定，要给操作系统和JVM本身留下一定的剩余时间。

推荐配置系统或容器里可用内存的70%-80%最好。

### 假设物理内存是8G，设置多大的堆内存比较合适

比如说系统有 8G 物理内存，系统自己可能会用掉一点，大概还有 7.5G 可以用，那 么建议配置` ‐Xmx6g` 。

说明: `7.5G*0.8 = 6G` ，如果知道系统里有明确使用堆外内存的地方，还需要进一步降低这个值。

### `-Xmx`设置的值与JVM进程所占用的内存有什么关系

JVM总内存=栈+堆+非堆+堆外+Native

### 怎么开启GC日志

一般来说，JDK8及以下版本通过以下参数来开启GC日志:

```
‐XX:+PrintGCDetails ‐XX:+PrintGCDateStamps ‐Xloggc:gc.log
```

如果是在JDK9以上的版本，则格式略有不同：

```
‐Xlog:gc*=info:file=gc.log:time:filecount=0
```

### 如何指定使用G1垃圾收集器启动程序

```
java ‐XX:+UseG1GC
‐Xms4g
‐Xmx4g
‐Xloggc:gc.log
‐XX:+PrintGCDetails
‐XX:+PrintGCDateStamps
Hello
```

## Java8默认使用的垃圾收集器是什么

Java8版本的Hotspot JVM，默认情况下使用的是并行垃圾收集器(Parallel GC)。其他厂商提供的JDK8基本上也默认使用并行垃圾收集器。

## Java11的默认垃圾收集器是什么?

Java9之后，官方JDK默认使用的垃圾收集器是G1。

### 常见的垃圾收集器有哪些

常见的垃圾收集器包括:

- 串行垃圾收集器: ‐XX:+UseSerialGC 

- 并行垃圾收集器: ‐XX:+UseParallelGC 

- CMS垃圾收集器: ‐XX:+UseConcMarkSweepGC 

- G1垃圾收集器: ‐XX:+UseG1GC

### 什么是串行垃圾收集

只有单个worker线程来执行GC工作。

### 什么是并行垃圾收集器

并行垃圾收集，是指使用多个GC worker 线程并行的执行垃圾收集，能够充分的利用多核CPU的能力，缩短垃圾收集的暂停时间。

除了Serial GC，其他的垃圾收集器，比如PS，CMS，G1等新的垃圾收集器都使用了多个线程来并行执行GC工作。

### 什么是并发垃圾收集器

并发垃圾收集器，是指在应用程序在正常执行时，有一部分GC任务，有GC线程在应用线程一起并发执行。例如CMS/G1的各种并发阶段。

### 什么是增量式垃圾收集

首先，G1的堆内存不再单纯划分为我年轻代和老年代，而是划分为了多个（通常是2048个）可以存放对象的小堆块区域（smaller heap regions）。

每个小块，可能一会被定义为Eden区，一会被指定为Survivor区或者Old区，这样划分之后，使得G1不必每次都去回收整个堆空间，而是以增量的方式来进行处理：每次只处理一部分内存块，称为此次GC的回收集（collection set）。

下次GC时在本次的基础上，再选定一定的区域来进行回收。增量式垃圾收集的好处是大大降低了单词GC暂停的时间。

### 什么是年轻代

年轻代是分来垃圾收集算法中的一个概念，相对于老年代而言，年轻代一般包括:

- 新生代，Eden区。

-  存活区，执行年轻代GC时，用存活区来保存活下来的对象。 存活区也是年轻代的一部分，但一般有2个存活区，所以可以来回倒腾。

### 什么是GC停顿（GC pause）

因为GC过程中，有一部分操作需要等所有应用线程都到达安全点，暂停之后才能执 行，这时候就叫做GC停顿，或者叫做GC暂停。

### GC停顿与STW停顿有什么区别

这两者一般可以认为就是同一个意思。

## 如果CPU使用率突然飙升怎么排查

缺乏经验的话，针对当前问题，往往需要使用不同的工具来收集信息，例如:

- 收集不同的指标(CPU，内存，磁盘IO，网络等等) 分析应用日志
- 分析GC日志
- 获取线程转储并分析
- 获取堆转储来进行分析

### 系统性能一般怎么衡量

可量化的3个性能指标：

- 系统容量：比如硬件配置，设计容量
- 吞吐量：最直观的指标是TPS
- 响应时间：也就是系统延迟，包括服务端延时和网络延迟

## 使用过哪些JVM相关工具

### 查看JVM进行好的命令是什么

可以使用`ps -ef`和`jsp -v`等等

### 怎么查看剩余内存

比如：`free -m`,`free -h`,`top`命令等等

### 查看线程栈的工具是什么

一般先使用jps命令，再使用`jstack -l`

### 用什么工具来获取堆内存转储

一般使用jmap工具来获取堆内存快照

### 内存Dump时有哪些注意事项

根据实际情况来看，获取内存快照可能会让系统暂停或阻塞一段时间，根据内存量决定。

使用jmap时，如果指定live参数，则额会触发一次FullGC，需要注意。

### 使用jmap转储堆内存大致的参数怎么设置

示例：`jmap -dump:format=b,file=xxx.hprof pid`

### 为什么转储文件以`.hprof`结尾

JVM有个内置的分析器叫做HPROF，堆内存转储文件的格式，最早就是这款工具定义的。

### 内存Dump完成后，用什么工具来分析

一般使用Eclipse MAT工具或者jhat工具来处理