JVM入门

1. 概述

• 什么是 JVM？

  JVM 即 Java Virtual Machine ，是 Java 程序的运行环境（ java 二进制字节码的运行环境）

• JVM 优点：

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

• 比较JVM、JRE、JDK

  

• 学习JVM的用处

  • 面试
  • 理解底层的实现原理
  • 中高级程序员的必备技能

本文章以HotSpot为基础进行分析

2. 内存结构

2.1 程序计数器

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

先看下面的这段代码

//二进制字节码（jvm指令）			java源代码
0: getstatic #20 			// PrintStream out = System.out;
3: astore_1 			    // --
4: aload_1 					// out.println(1);
5: iconst_1 				// --
6: invokevirtual #26 		 // --
9: aload_1 					// out.println(2);
10: iconst_2 				// --
11: invokevirtual #26 		// --
14: aload_1 				// out.println(3);
15: iconst_3 				// --
16: invokevirtual #26 		// --
19: aload_1 				// out.println(4);
20: iconst_4 				// --
21: invokevirtual #26 		// --
24: aload_1					 // out.println(5);
25: iconst_5 				// --
26: invokevirtual #26 		// --
29: return

java源代码会先编译成二进制字节码，二进制字节码通过解释器解释成为机器码，把机器码交给CPU来进行执行。

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

可以把指令前的数字看作是地址，当解释执行第一条指令的时候，程序计数器就会记住下一条指令的执行地址，也就是3，而解释执行第二条指令的时候，程序计数器就会记住4。

在物理上，实现程序计数器是通过寄存器来实现的

程序计数器的特点：

• 是线程私有的。每个线程都有各自的程序计数器，因为每个线程的代码jvm指令执行地址不同
• 不会存在内存溢出。是JVM中唯一一个不会存在内存溢出的区。

总结：

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

2.2 虚拟机栈

2.2.1 概述

栈：可以把栈看作子弹夹

具有先进后出的特点

Java Virtual Machine Stacks （Java 虚拟机栈）

一个线程运行时需要给这个线程划分内存空间，虚拟机栈即每个线程运行时需要的内存空间，多个线程就会有多个虚拟机栈

每个栈由多个栈帧（Frame）组成，每个栈帧对应着每次方法调用时所占用的内存，当对应方法运行完毕后栈帧就会出栈，释放内存

每个线程只能由一个活动栈帧，对应着当前正在执行的那个方法

将Frames看作是虚拟机栈，在Frames中，最顶部的为活动栈帧。

• 常见问题辨析

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

    不涉及。栈内存是方法调用产生的栈帧内存，而栈帧内存在方法运行结束后栈帧出栈，内存自动回收。

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

    我们可以通过-Xss参数设置分配栈内存，在不设置栈内存的情况下，默认情况如下：

    • Linux/x64(64-bit)：1024KB
    • macOS(64-bit)：1024KB
    • Oracle Solaris/x64(64-bit)：1024KB
    • Windiws：取决于windows的虚拟内存

    手动设置栈内存：

    -Xss1m
    -Xss1024k
    -Xss1048576
    

    那么是不是栈内存越大，程序运行越快呢？

    并不是，栈内存越大，反而会让线程数变少。因为物理内存的大小是固定的，假设一个线程所用的栈内存为1M，总物理内存为500M，那么理论上就可以有500个线程同时运行，但是如果一个线程所用的栈内存为2M，则理论上只能有250个线程同时运行。将栈内存设置较大，只能有更多的方法递归调用，而不能是程序运行更快。

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

    判断一个变量是否线程安全，就要看多个线程对这个变量是共享的还是私有的。

    看如下程序：

    public class Demo1_2 {
        static void m1(){
            int x = 0;
            for (int i = 0; i < 5000; i++) {
                x++;
            }
            System.out.println(x);
        }
    }
    

    多个线程执行上面的代码，会不会造成混乱呢？

    不会，因为x是在方法内的局部变量，一个线程对应一个栈，线程内每一次方法调用，都会产生一个新的栈帧。相当于每个线程都有一个私有的x变量，所以两个线程的x互不干扰。

    如果是以下程序：

    public class Demo1_3 {
        static int x = 0;
        //多个线程同时执行此方法
        static void m1(){
            for (int i = 0; i < 5000; i++) {
                x++;
            }
            System.out.println(x);
        }
    }
    

    多个线程共享x变量，各个线程操作x之后会将值返回重新赋值给x，因此会出现线程安全

    再看下面这个程序：

    public class Demo1_4 {
        public static void main(String[] args) {
            StringBuilder sb = new StringBuilder();
            sb.append(4);
            sb.append(5);
            sb.append(6);
            new Thread(()->{
                m2(sb);
            }).start();
        }
    
        public static void m1() {
            StringBuilder sb = new StringBuilder();
            sb.append(1);
            sb.append(2);
            sb.append(3);
            System.out.println(sb.toString());
        }
    
        public static void m2(StringBuilder sb) {
            sb.append(1);
            sb.append(2);
            sb.append(3);
            System.out.println(sb.toString());
        }
    
        public static StringBuilder m3() {
            StringBuilder sb = new StringBuilder();
            sb.append(1);
            sb.append(2);
            sb.append(3);
            return sb;
        }
    }
    
    

    m1()方法的sb并不会发生线程安全问题，推理过程与之前局部变量x同理

    m2()方法不同的是，sb并不是方法内的一个变量，而是方法的一个参数。那么这个sb并不是线程安全的，因为sb通过参数传递进来，那么极有可能其他线程也可以访问到它，不再是线程私有的。main()方法中主线程修改了sb，m2()方法也修改了sb，因此不是线程安全的。

    m3()方法也不能保证sb的线程安全，与m2()方法类似，虽然当前StringBuilder对象是方法内的局部变量，但是最终作为返回结果返回，返回就意味着其他线程可以拿到这个对象的引用去并发修改，因此会造成线程安全问题。

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

2.2.2 栈内存溢出

在开发过程中，会经常遇到一个问题：栈内存溢出

什么情况会导致栈内存溢出？

• 栈帧过多导致栈内存溢出（如方法递归调用而未设置正确的结束条件）

  /**
   * 演示栈内存溢出
   */
  public class Demo1_5 {
      private static int count;
  
      public static void main(String[] args) {
          try {
              method1();
          } catch (Throwable e) {
              e.printStackTrace();
              System.out.println(count);
          }
      }
  
      private static void method1() {
          count++;
          method1();
      }
  }
  
  /*
  java.lang.StackOverflowError
  	at Unit1.Demo1_5.method1(Demo1_5.java:23)
  	...
  23290
  */
  

  有些时候并不是我们的代码导致了内存溢出，在实际开发中有些时候第三方类库也会导致StackflowError

  public class Demo1_6 {
      public static void main(String[] args) throws JsonProcessingException {
          Dept d = new Dept();
          d.setName("Market");
  
          Emp e1 = new Emp();
          e1.setName("zhang");
          e1.setDept(d);
  
          Emp e2 = new Emp();
          e2.setName("li");
          e2.setDept(d);
  
          d.setEmps(Arrays.asList(e1, e2));
  
          // { name: 'Market', emps: [{ name:'zhang', dept:{ name:'', emps: [ {}]} },] }
          ObjectMapper mapper = new ObjectMapper();
          System.out.println(mapper.writeValueAsString(d));
      }
  }
  
  class Emp {
      private String name;
      private Dept dept;
  
      public String getName() {
          return name;
      }
  
      public void setName(String name) {
          this.name = name;
      }
  
      public Dept getDept() {
          return dept;
      }
  
      public void setDept(Dept dept) {
          this.dept = dept;
      }
  }
  
  class Dept {
      private String name;
      private List<Emp> emps;
  
      public String getName() {
          return name;
      }
  
      public void setName(String name) {
          this.name = name;
      }
  
      public List<Emp> getEmps() {
          return emps;
      }
  
      public void setEmps(List<Emp> emps) {
          this.emps = emps;
      }
  }
  
  

  在这个程序中会出现 Infinite recursion (StackOverflowError) 无限递归（栈内存溢出）的错误

  emp中包含dept，而dept中又包含了emp，因此会出现无限递归。两个类互相调用，导致无法转换。这里可以使用 @JsonIgnore 注解，添加到dept中的emp属性上，这样在转换JSON的时候就会忽略emp

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

2.2.3 线程运行诊断

案例1：CPU占用过多

• Linux下后台运行Java程序（nohup java com.mark.jvm.Demo1_7）

• 定位

  • 通过top命令可以实时监测进程的资源占用

  • 查询到该占用资源过高的PID，再通过 ps H -eo pid,tid,%cpu | grep 进程id 查询占用资源过高的线程（ps命令可以查询线程对CPU的占用情况，H就是打印进程的所有线程信息，-eo选择展示的列的信息，通过grep进行筛选进程）

  • 命令jstack 进程id 可以将java进程中所有的线程列出来

    • 可以根据线程id（在第二步的线程id为10进制，而jstack输出的线程编号为16进制的，因此要进行换算）找到有问题的线程，进一步定位到问题代码的源码行号

  • 可以定位到是第5行的while死循环导致CPU占用过高

    public class Demo1_7 {
        public static void main(String[] args) {
            new Thread(null, () -> {
                System.out.println("1...");
                while(true) {
    
                }
            }, "thread1").start();
            new Thread(null, () -> {
                System.out.println("2...");
                try {
                  	Thread.sleep(1000000L);
                } catch (InterruptedException e) {
                  	e.printStackTrace();
                }
            }, "thread2").start();
            new Thread(null, () -> {
              System.out.println("3...");
              try {
                Thread.sleep(1000000L);
              } catch (InterruptedException e) {
                e.printStackTrace();
              }
            }, "thread3").start();
            }
        }
    

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

排查方式：使用jstack 进程id命令

2.3 本地方法栈

在JVM虚拟机调用一些本地方法时，需要给本地方法提供的内存空间就叫做本地方法栈（Native Method Stacks）

本地方法指的是哪些不是由Java代码编写的方法，因为Java代码是由一定限制的，Java代码有些时候并不能直接与操作系统的底层进行交互，需要C/C++语言编写的本地方法来真正与操作系统交互。本地方法运行时所需要的内存空间就叫做本地方法栈。

例如：Object类，是所有类的基类，Object有以下几个方法：

protected native Object clone() throws CloneNotSupportedException;

public native int hashCode();

public final native void notify();

public final native void notifyAll();

public final native void wait(long timeout) throws InterruptedException;

native修饰的方法是没有实现的，它的实现都是由C/C++实现。Java通过本地方法接口间接调用C/C++。

2.4 堆

2.4.1 定义

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

特点：

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

2.4.2 堆内存溢出

如果不断产生对象，而且产生的对象仍然在使用，这些对象不能当作垃圾被回收，这样的对象到一定数量就会导致堆内存溢出。

public class Demo1_8 {
    public static void main(String[] args) {
        int i = 0;
        try {
            List<String> list = new ArrayList<>();
            String a = "hello";
            while (true) {
                list.add(a); // hello, hellohello, hellohellohellohello ...
                a = a + a;  // hellohellohellohello
                i++;
            }
        } catch (Throwable e) {
            e.printStackTrace();
            System.out.println(i);
        }
    }
}
/*
java.lang.OutOfMemoryError: Java heap space
	at java.util.Arrays.copyOf(Arrays.java:3332)
	at java.lang.AbstractStringBuilder.ensureCapacityInternal(AbstractStringBuilder.java:124)
	at java.lang.AbstractStringBuilder.append(AbstractStringBuilder.java:448)
	at java.lang.StringBuilder.append(StringBuilder.java:142)
	at Unit1.Demo1_8.main(Demo1_8.java:20)
26
*/

上面的代码在运行一段时间后就会抛出异常：java.lang.OutOfMemoryError: Java heap space Java堆空间不足

可以通过-Xmx来控制堆空间的大小

-Xmx8m
-Xmx4g

2.4.3 堆内存诊断

• jps 工具

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

• jmap 工具

  查看堆内存占用情况（只能查看某一时刻的） jmap - heap 进程id

  运行代码如下：

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

  打开控制台，输入命令jps查看Demo1_9的进程号，分别在输出1、2、3之后输入命令 jmap - heap 进程id

  PS D:\Code\In-depth_JavaSE\myThread\target\classes\com\mark\finght> jps
  11744 RemoteMavenServer36
  2120 Demo1_9
  23160 Launcher
  5320 Jps
  22828 
  PS D:\Code\In-depth_JavaSE\myThread\target\classes\com\mark\finght> jmap -heap 2120 #查看2120Java进程的堆内存占用
  Attaching to process ID 2120, please wait...
  Debugger attached successfully.
  Server compiler detected.
  JVM version is 25.341-b10
  
  using thread-local object allocation.
  Parallel GC with 10 thread(s)
  
  Heap Configuration:		#堆的配置信息
     MinHeapFreeRatio         = 0
     MaxHeapFreeRatio         = 100
     MaxHeapSize              = 3172990976 (3026.0MB)	 	#最大堆内存
     NewSize                  = 66060288 (63.0MB)
     MaxNewSize               = 1057488896 (1008.5MB)		#最大新生代内存
     OldSize                  = 133169152 (127.0MB)		#老年代内存
     NewRatio                 = 2
     SurvivorRatio            = 8
     MetaspaceSize            = 21807104 (20.796875MB)
     CompressedClassSpaceSize = 1073741824 (1024.0MB)
     MaxMetaspaceSize         = 17592186044415 MB
     G1HeapRegionSize         = 0 (0.0MB)
  
  Heap Usage:		#堆内存占用
  PS Young Generation
     0.0% used
  PS Old Generation
     capacity = 133169152 (127.0MB)
     used     = 0 (0.0MB)
     free     = 133169152 (127.0MB)
     0.0% used
  
  3180 interned Strings occupying 260920 bytes.
  
  PS D:\Code\In-depth_JavaSE\myThread\target\classes\com\mark\finght> jmap -heap 2120
  Attaching to process ID 2120, please wait...
  Debugger attached successfully.
  Server compiler detected.
  JVM version is 25.341-b10
  
  using thread-local object allocation.
  Parallel GC with 10 thread(s)
  
  Heap Configuration:
     MinHeapFreeRatio         = 0
     MaxHeapFreeRatio         = 100
     MaxHeapSize              = 3172990976 (3026.0MB)
     NewSize                  = 66060288 (63.0MB)
     MaxNewSize               = 1057488896 (1008.5MB)
     OldSize                  = 133169152 (127.0MB)
     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:		#新创建的对象都会使用名为Eden的区
     capacity = 50331648 (48.0MB)		#总内存48MB
     used     = 15519552 (14.80059814453125MB)	#已经使用了14MB
     free     = 34812096 (33.19940185546875MB)
     30.834579467773438% used
  From Space:
     capacity = 7864320 (7.5MB)
     used     = 0 (0.0MB)
     free     = 7864320 (7.5MB)
     0.0% used
  To Space:
     capacity = 7864320 (7.5MB)
     used     = 0 (0.0MB)
     free     = 7864320 (7.5MB)
     0.0% used
  PS Old Generation
     capacity = 133169152 (127.0MB)
     used     = 0 (0.0MB)
     free     = 133169152 (127.0MB)
     0.0% used
  
  3181 interned Strings occupying 260968 bytes.
  PS D:\Code\In-depth_JavaSE\myThread\target\classes\com\mark\finght> jmap -heap 2120
  Attaching to process ID 2120, please wait...
  Debugger attached successfully.
  Server compiler detected.
  JVM version is 25.341-b10
  
  using thread-local object allocation.
  Parallel GC with 10 thread(s)
  
  Heap Configuration:
     MinHeapFreeRatio         = 0
     MaxHeapFreeRatio         = 100
     MaxHeapSize              = 3172990976 (3026.0MB)
     NewSize                  = 66060288 (63.0MB)
     MaxNewSize               = 1057488896 (1008.5MB)
     OldSize                  = 133169152 (127.0MB)
     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 = 50331648 (48.0MB)
     used     = 1006656 (0.96002197265625MB)	#使用了0.96MB
     free     = 49324992 (47.03997802734375MB)
     2.0000457763671875% used
  From Space:
     capacity = 7864320 (7.5MB)
     used     = 0 (0.0MB)
     free     = 7864320 (7.5MB)
     0.0% used
  To Space:
     capacity = 7864320 (7.5MB)
     used     = 0 (0.0MB)
     free     = 7864320 (7.5MB)
     0.0% used
  PS Old Generation
     capacity = 133169152 (127.0MB)
     used     = 1007032 (0.9603805541992188MB)
     free     = 132162120 (126.03961944580078MB)
     0.7562051607867865% used
  
  3167 interned Strings occupying 259976 bytes.
  
  

• jconsole 工具

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

  运行程序后，在控制台输入jconsole

  

  连接Demo1_9对应的进程即可查看到堆内存的变化

  

案例：垃圾回收后，内存占用仍然很高

运行一个程序Demo1_10 先不用管是什么程序

输入命令：jps jmap - heap 进程id

PS D:\Code\In-depth_JavaSE\myThread\target\classes\com\mark\finght> jmap -heap 12456
Attaching to process ID 12456, please wait...
Debugger attached successfully.
Server compiler detected.
JVM version is 25.341-b10

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

Heap Configuration:
   MinHeapFreeRatio         = 0
   MaxHeapFreeRatio         = 100
   MaxHeapSize              = 3172990976 (3026.0MB)
   NewSize                  = 66060288 (63.0MB)
   MaxNewSize               = 1057488896 (1008.5MB)
   OldSize                  = 133169152 (127.0MB)
   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 = 100663296 (96.0MB)
   used     = 20686832 (19.728500366210938MB)
   free     = 79976464 (76.27149963378906MB)
   20.55052121480306% used
From Space:
   capacity = 7864320 (7.5MB)
   0.0% used
PS Old Generation
   capacity = 376438784 (359.0MB)
   used     = 193590088 (184.62189483642578MB)
   free     = 182848696 (174.37810516357422MB)
   51.4267116536005% used

3164 interned Strings occupying 259832 bytes.

新生代Eden 19 + 老年代used 184 = 占用内存大约为203MB

打开jconsole

执行请求垃圾回收后，发现内存占用仍然很高，只下降了一点

这时执行jmap -heap 进程id

PS D:\Code\In-depth_JavaSE\myThread\target\classes\com\mark\finght> jmap -heap 12456
Attaching to process ID 12456, please wait...
Debugger attached successfully.
Server compiler detected.
JVM version is 25.341-b10

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

Heap Configuration:
   MinHeapFreeRatio         = 0
   MaxHeapFreeRatio         = 100
   MaxHeapSize              = 3172990976 (3026.0MB)
   NewSize                  = 66060288 (63.0MB)
   MaxNewSize               = 1057488896 (1008.5MB)
   OldSize                  = 133169152 (127.0MB)
   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 = 163577856 (156.0MB)
   used     = 6543224 (6.240104675292969MB)
   free     = 157034632 (149.75989532470703MB)
   4.000067099546775% used
From Space:
   capacity = 524288 (0.5MB)
   used     = 0 (0.0MB)
   free     = 524288 (0.5MB)
   0.0% used
To Space:
   capacity = 7864320 (7.5MB)
   used     = 0 (0.0MB)
   free     = 7864320 (7.5MB)
   0.0% used
PS Old Generation
   capacity = 376438784 (359.0MB)
   used     = 212077296 (202.25267028808594MB)
   free     = 164361488 (156.74732971191406MB)
   56.33779116659775% used

5630 interned Strings occupying 467008 bytes.

发现新生代的Eden占用内存下降，而老年代的内存没有被回收掉

可以使用工具jvisualvm可视化虚拟机

public class Demo1_10 {
    public static void main(String[] args) throws InterruptedException {
        List<Student> students = new ArrayList<>();
        for (int i = 0; i < 200; i++) {
            students.add(new Student());
//            Student student = new Student();
        }
        Thread.sleep(1000000000L);
    }
}

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

2.5 方法区

2.5.1 定义

Java虚拟机有一个在所有Java虚拟机线程之间共享的方法区域。

方法区类似于用于传统语言的编译代码的存储区，或者类似于操作系统进程中的“文本”段。
它存储每个类的结构，如运行时常量池、字段和方法数据，以及方法和构造函数的代码，包括类和实例初始化以及接口初始化中使用的特殊方法(类的构造器)。
方法区域是在虚拟机启动时创建的。
尽管方法区域在逻辑上是堆的一部分，但简单的实现可能选择不进行垃圾收集或将其压缩。
本规范不强制指定方法区域的位置或用于管理编译代码的策略。
方法区域可以是固定大小的，也可以根据计算需要进行扩展，并且如果不需要更大的方法区域，则可以缩小。
方法区域的内存不需要是连续的。
Java虚拟机实现可以向程序员或用户提供对方法区域的初始大小的控制，以及在大小可变的方法区域的情况下，对最大和最小方法区域大小的控制。
以下异常情况与方法区域相关：
如果方法区域中的内存不能用于满足分配请求，则Java虚拟机将抛出OutOfMemoyError。

——官方文档

2.5.2 方法区内存溢出

来看这样一段代码

-XX:MaxMetaspaceSize 设置最大元空间

/**
 * 演示元空间内存溢出 java.lang.OutOfMemoryError: Metaspace
 * -XX:MaxMetaspaceSize=8m 最大元空间大小为8M
 */
public class Demo1_11 extends ClassLoader { // ClassLoader可以用来加载类的二进制字节码
    public static void main(String[] args) {
        int j = 0;
        try {
            Demo1_11 test = new Demo1_11();
            for (int i = 0; i < 10000; i++, j++) {
                // ClassWriter 作用是生成类的二进制字节码
                ClassWriter cw = new ClassWriter(0);
                // 版本号， 类的访问修饰符：public， 类名, 包名, 父类， 接口
                cw.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, "Class" + i, null, "java/lang/Object", null);
                // 返回 byte[]
                byte[] code = cw.toByteArray();
                // 执行了类的加载
                test.defineClass("Class" + i, code, 0, code.length); // Class 对象
            }
        } finally {
            System.out.println(j);
        }
    }
}

在限制元空间或永久代的内存后，运行该程序会出现异常：java.lang.OutOfMemoryError: Metaspace 或 java.lang.OutOfMemoryError: PermGen space

实际开发中可能出现方法区内存溢出的场景：

• Spring框架
• MyBatis框架

2.5.3 运行时常量池

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello World");
    }
}

这段程序对于开发者来说一定不陌生，它在运行时先编译成class二进制字节码，字节码一般来说由三部分组成：类基本信息、常量池、类方法定义（包含了虚拟机指令）

找到HelloWorld.class所在目录，执行命令javap -v HelloWorld.class 反编译，-v表示显示详细参数

//类的基本信息
Classfile /D:/Code/In-depth_JavaSE/myJVM/target/classes/Unit1/HelloWorld.class //类文件
  Last modified 2022-11-10; size 545 bytes //最后修改时间
  MD5 checksum 3450ab2d46d1d3b27fcf77aa70ca9bad	//签名
  Compiled from "HelloWorld.java"
public class Unit1.HelloWorld
  minor version: 0
  major version: 52	//jdk内部版本
  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            // Unit1/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               LUnit1/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               Unit1/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 Unit1.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 9: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       5     0  this   LUnit1/HelloWorld;
  //main方法
  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                  // 获取静态变量 System.out  根据#2查询常量池
         3: ldc           #3                  // 加载参数String Hello World 根据#3查找引用地址或常量
         5: invokevirtual #4                  // 执行虚方法调用System.out.println 根据#4查找虚方法
         8: return
      LineNumberTable:
        line 11: 0
        line 12: 8
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       9     0  args   [Ljava/lang/String;
}
SourceFile: "HelloWorld.java"

因此可以发现，常量池就是给类方法定义中的jvm指令提供一些常量符号，根据常量符号找到对应的信息

运行时常量池

• 常量池，就是一张表，虚拟机指令根据这张常量表找到要执行的类名、方法名、参数类型、字面量等信息

• *运行时常量池，常量池是 .class 文件中的，当该类被加载，它的常量池信息就会放入运行时常量

  池，并把里面的符号地址变为真实地址

2.6 StringTable

StringTable是运行时常量池中比较重要的组成部分，也就是俗称的串池

先看这个面试题

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);
System.out.println(s3 == s5);
System.out.println(s3 == s6);
String x2 = new String("c") + new String("d");
String x1 = "cd";
x2.intern();
// 问，如果调换了【最后两行代码】的位置呢，如果是jdk1.6呢
System.out.println(x1 == x2);

为了弄清楚这道题，需要从字节码常量池的角度来分析这些代码的底层原理

public class Demo1_12 {
    public static void main(String[] args) {
        String s1 = "a";
        String s2 = "b";
        String s3 = "ab";
        String s4 = s1 + s2;
        String s5 = "a" + "b";
    }
}

反编译：

Classfile /D:/Code/In-depth_JavaSE/myJVM/target/classes/Unit1/Demo1_12.class
  Last modified 2022-11-10; size 695 bytes
  MD5 checksum fe9b707eda1a65d0f1c2c19857d48329
  Compiled from "Demo1_12.java"
public class Unit1.Demo1_12
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Methodref          #10.#30        // java/lang/Object."<init>":()V
   #2 = String             #31            // a
   #3 = String             #32            // b
   #4 = String             #33            // ab
   #5 = Class              #34            // java/lang/StringBuilder
   #6 = Methodref          #5.#30         // java/lang/StringBuilder."<init>":()V
   #7 = Methodref          #5.#35         // java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
   #8 = Methodref          #5.#36         // java/lang/StringBuilder.toString:()Ljava/lang/String;
   #9 = Class              #37            // Unit1/Demo1_12
  #10 = Class              #38            // java/lang/Object
  #11 = Utf8               <init>
  #12 = Utf8               ()V
  #13 = Utf8               Code
  #14 = Utf8               LineNumberTable
  #15 = Utf8               LocalVariableTable
  #16 = Utf8               this
  #17 = Utf8               LUnit1/Demo1_12;
  #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               s5
  #28 = Utf8               SourceFile
  #29 = Utf8               Demo1_12.java
  #30 = NameAndType        #11:#12        // "<init>":()V
  #31 = Utf8               a
  #32 = Utf8               b
  #33 = Utf8               ab
  #34 = Utf8               java/lang/StringBuilder
  #35 = NameAndType        #39:#40        // append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
  #36 = NameAndType        #41:#42        // toString:()Ljava/lang/String;
  #37 = Utf8               Unit1/Demo1_12
  #38 = Utf8               java/lang/Object
  #39 = Utf8               append
  #40 = Utf8               (Ljava/lang/String;)Ljava/lang/StringBuilder;
  #41 = Utf8               toString
  #42 = Utf8               ()Ljava/lang/String;
{
  public Unit1.Demo1_12();
    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 9: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       5     0  this   LUnit1/Demo1_12;

  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=6, args_size=1
         0: ldc           #2                  // 加载字符串对象引用 String a
         2: astore_1						//将加载好的字符串对象存入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: ldc           #4                  // String ab
        31: astore        5
        33: return
      LineNumberTable:
        line 11: 0
        line 12: 3
        line 13: 6
        line 14: 9
        line 15: 29
        line 16: 33
      //main方法栈帧运行时局部变量表
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      34     0  args   [Ljava/lang/String;
            3      31     1    s1   Ljava/lang/String;	//	将a存入1的位置
            6      28     2    s2   Ljava/lang/String;
            9      25     3    s3   Ljava/lang/String;
           29       5     4    s4   Ljava/lang/String;
           33       1     5    s5   Ljava/lang/String;
}
SourceFile: "Demo1_12.java"

常量池与串池的关系：

常量池中的信息最初在字节码文件中，在运行时就会被加载到运行时常量池，在加载完成时，这时a、b、ab仅仅是常量池中的符号，还没有成为java字符串对象，当main方法执行到引用它的那一行代码上时，ldc #2就会把a符号变成”a“字符串对象，而在此之前会准备好一块空间：StringTable（是一个HashTable，且长度固定不可扩容），会把"a"对象作为key在StringTable中寻找，刚开始StringTable是空的，没有找到，就会把”a“对象放入StringTable中，此时StringTable就会有”a“字符串对象了。（延迟加载）

// StringTable [ "a", "b" ,"ab" ]  hashtable 结构，不能扩容
public class Demo1_22 {
    // 常量池中的信息，都会被加载到运行时常量池中， 这时 a b ab 都是常量池中的符号，还没有变为 java 字符串对象
    // ldc #2 会把 a 符号变为 "a" 字符串对象
    // ldc #3 会把 b 符号变为 "b" 字符串对象
    // ldc #4 会把 ab 符号变为 "ab" 字符串对象

    public static void main(String[] args) {
        String s1 = "a"; // 懒惰的
        String s2 = "b";
        String s3 = "ab";
        String s4 = s1 + s2; // new StringBuilder().append("a").append("b").toString()  new String("ab") s4字符串是new出来的对象，放在了堆中
        String s5 = "a" + "b";  // javac 在编译期间的优化，"a"、"b"为常量,结果已经在编译期确定为ab
        System.out.println(s3 == s4);	//false
        System.out.println(s3 == s5);	//true
    }
}

字符串字面量是延迟成为对象的

2.6.1 StringTable特性

• 常量池中的字符串仅是符号，第一次用到时才变为对象

• 利用串池的机制，来避免重复创建字符串对象

• 字符串变量拼接的原理是 StringBuilder （Java8）

• 字符串常量拼接的原理是编译期优化

• 可以使用 intern 方法，主动将串池中还没有的字符串对象放入串池

  public class Demo1_13 {
      //  ["ab", "a", "b"]
      public static void main(String[] args) {
          String x = "ab";
          String s = new String("a") + new String("b");
          // 堆  new String("a")   new String("b") => new String("ab")
          String s2 = s.intern(); // 将这个字符串对象尝试放入串池，如果有则并不会放入，如果没有则放入串池， 会把串池中的对象返回
          System.out.println(s2 == x);	//true
          System.out.println(s == s2);	//false
          System.out.println(s == x);		//false
      }
  }
  

  public class Demo1_13 {
      //  ["ab", "a", "b"]
      public static void main(String[] args) {
  
          String s = new String("a") + new String("b");
          // 堆  new String("a")   new String("b") => new String("ab")
          String s2 = s.intern(); // 将这个字符串对象尝试放入串池，如果有则并不会放入，如果没有则放入串池， 会把串池中的对象返回
          String x = "ab";
          System.out.println(s2 == x);	//true
          System.out.println(s == s2);	//true
          System.out.println(s == x);		//true
      }
  }
  

  • 1.8 将这个字符串对象尝试放入串池，如果有则并不会放入，如果没有则放入串池， 会把串池中的对象返回
  • 1.6 将这个字符串对象尝试放入串池，如果有则并不会放入，如果没有会把此对象复制一份，放入串池， 会把串池中的对象返回

现在再来看刚刚的面试题：

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 x1 = x2.intern();
System.out.println(x1 == x2);	//false

// 问，如果调换了【最后两行代码】的位置呢，如果是jdk1.6呢
/*
如果是
x2.intern();
String x1 = "cd";
则为true
如果是jdk1.6
则为false
*/

2.6.2 StringTable位置

再Java1.6中，StringTable是常量池的一部分，常量池存储在永久代中

而从Java1.7开始，就将StringTable转移到了堆中，因为永久代的内存效率很低，而StringTable又使用频繁。

/**
 * 演示 StringTable 位置
 * 在jdk8下设置 -Xmx10m -XX:-UseGCOverheadLimit	堆最大内存为10M ，
 * 在jdk6下设置 -XX:MaxPermSize=10m 设置永久代最大内存为10m
 */
public class Demo1_15 {
    public static void main(String[] args) throws InterruptedException {
        List<String> list = new ArrayList<String>();
        int i = 0;
        try {
            for (int j = 0; j < 260000; j++) {
                list.add(String.valueOf(j).intern());
                i++;
            }
        } catch (Throwable e) {
            e.printStackTrace();
        } finally {
            System.out.println(i);
        }
    }
}

2.6.3 StringTable垃圾回收

/**
 * 演示 StringTable 垃圾回收
 * -Xmx10m 设置虚拟机堆内存最大值
 * -XX:+PrintStringTableStatistics 打印字符串表的统计信息
 * -XX:+PrintGCDetails  -verbose:gc 打印垃圾回收的详细信息
 */
public class Demo1_16 {
    public static void main(String[] args) throws InterruptedException {
        int i = 0;
        try {

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

0
//垃圾回收的详细信息(还没有发生垃圾回收，发生后会打印GC...)
Heap
 PSYoungGen      total 2560K, used 1841K [0x00000000ffd00000, 0x0000000100000000, 0x0000000100000000)
  eden space 2048K, 89% used [0x00000000ffd00000,0x00000000ffecc440,0x00000000fff00000)
  from space 512K, 0% used [0x00000000fff80000,0x00000000fff80000,0x0000000100000000)
  to   space 512K, 0% used [0x00000000fff00000,0x00000000fff00000,0x00000000fff80000)
 ParOldGen       total 7168K, used 0K [0x00000000ff600000, 0x00000000ffd00000, 0x00000000ffd00000)
  object space 7168K, 0% used [0x00000000ff600000,0x00000000ff600000,0x00000000ffd00000)
 Metaspace       used 3369K, capacity 4496K, committed 4864K, reserved 1056768K
  class space    used 369K, capacity 388K, committed 512K, reserved 1048576K
//符号表
SymbolTable statistics:
Number of buckets       :     20011 =    160088 bytes, avg   8.000
Number of entries       :     13722 =    329328 bytes, avg  24.000
Number of literals      :     13722 =    582944 bytes, avg  42.482
Total footprint         :           =   1072360 bytes
Average bucket size     :     0.686
Variance of bucket size :     0.690
Std. dev. of bucket size:     0.831
Maximum bucket size     :         6
//字符串表的统计信息
StringTable statistics:
Number of buckets       :     60013 =    480104 bytes, avg   8.000
Number of entries       :      1783 =     42792 bytes, avg  24.000
Number of literals      :      1783 =    159304 bytes, avg  89.346
Total footprint         :           =    682200 bytes
Average bucket size     :     0.030
Variance of bucket size :     0.030
Std. dev. of bucket size:     0.173
Maximum bucket size     :         3

向try块中添加如下代码

for (int j = 0; j < 100000; j++) { // j=100, j=10000
    String.valueOf(j).intern();
    i++;
}

[GC (Allocation Failure) [PSYoungGen: 2048K->504K(2560K)] 2048K->707K(9728K), 0.0062254 secs] [Times: user=0.00 sys=0.00, real=0.01 secs] 
[GC (Allocation Failure) [PSYoungGen: 2552K->488K(2560K)] 2755K->779K(9728K), 0.0014731 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[GC (Allocation Failure) [PSYoungGen: 2536K->488K(2560K)] 2827K->803K(9728K), 0.0009347 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
100000
Heap
 PSYoungGen      total 2560K, used 1558K [0x00000000ffd00000, 0x0000000100000000, 0x0000000100000000)
  eden space 2048K, 52% used [0x00000000ffd00000,0x00000000ffe0b8e0,0x00000000fff00000)
  from space 512K, 95% used [0x00000000fff00000,0x00000000fff7a020,0x00000000fff80000)
  to   space 512K, 0% used [0x00000000fff80000,0x00000000fff80000,0x0000000100000000)
 ParOldGen       total 7168K, used 315K [0x00000000ff600000, 0x00000000ffd00000, 0x00000000ffd00000)
  object space 7168K, 4% used [0x00000000ff600000,0x00000000ff64ee08,0x00000000ffd00000)
 Metaspace       used 3372K, capacity 4496K, committed 4864K, reserved 1056768K
  class space    used 369K, capacity 388K, committed 512K, reserved 1048576K
SymbolTable statistics:
Number of buckets       :     20011 =    160088 bytes, avg   8.000
Number of entries       :     13723 =    329352 bytes, avg  24.000
Number of literals      :     13723 =    582960 bytes, avg  42.481
Total footprint         :           =   1072400 bytes
Average bucket size     :     0.686
Variance of bucket size :     0.690
Std. dev. of bucket size:     0.831
Maximum bucket size     :         6
StringTable statistics:
Number of buckets       :     60013 =    480104 bytes, avg   8.000
Number of entries       :     20539 =    492936 bytes, avg  24.000
Number of literals      :     20539 =   1209744 bytes, avg  58.900
Total footprint         :           =   2182784 bytes
Average bucket size     :     0.342
Variance of bucket size :     0.358
Std. dev. of bucket size:     0.598
Maximum bucket size     :         4

2.6.4 StringTable性能调优

StringTable底层是一个HashTable，哈希表的性能是和他的大小密切相关的，如果HashTable桶的个数比较多，元素就相对分散，哈希碰撞的几率就会减少。反之，HashTable桶的个数比较少，哈希碰撞的几率增加，导致链表变长，查找的效率也会降低。

因此StringTable性能调优就是调整HashTable桶的个数

/**
 * 演示串池大小对性能的影响
 * -Xms500m -Xmx500m -XX:+PrintStringTableStatistics -XX:StringTableSize=1009
 */
public class Demo1_17 {
    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);
        }
    }
}

• 调整 -XX:StringTableSize=桶个数

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

  /**
   * 演示 intern 减少内存占用
   * -XX:StringTableSize=200000 -XX:+PrintStringTableStatistics
   * -Xsx500m -Xmx500m -XX:+PrintStringTableStatistics -XX:StringTableSize=200000
   */
  public class Demo1_18 {
      public static void main(String[] args) throws IOException {
  
          List<String> address = new ArrayList<>();
          System.in.read();
          for (int i = 0; i < 10; i++) {
              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;
                      }
                      //address.add(line);
                      address.add(line.intern());
                  }
                  System.out.println("cost:" + (System.nanoTime() - start) / 1000000);
              }
          }
          System.in.read();
      }
  }
  

2.7 直接内存

直接内存并不属于JVM的内存管理，而是属于系统内存。

Direct Memory 直接内存

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

2.7.1 直接内存基本使用

public class Demo1_19 {
    static final String FROM = "D:\\youtube\\Getting Started with Spring Boot-sbPSjI4tt10.mp4";
    static final String TO = "D:\\a.mp4";
    static final int _1Mb = 1024 * 1024;

    public static void main(String[] args) {
        io(); // io 用时：1535.586957 1766.963399 1359.240226
        directBuffer(); // directBuffer 用时：479.295165 702.291454 562.56592
    }

    private static void directBuffer() {
        long start = System.nanoTime();
        try (FileChannel from = new FileInputStream(FROM).getChannel();
             FileChannel to = new FileOutputStream(TO).getChannel();
        ) {
            ByteBuffer bb = ByteBuffer.allocateDirect(_1Mb);
            while (true) {
                int len = from.read(bb);
                if (len == -1) {
                    break;
                }
                bb.flip();
                to.write(bb);
                bb.clear();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        long end = System.nanoTime();
        System.out.println("directBuffer 用时：" + (end - start) / 1000_000.0);
    }

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

使用了directBuffer之后

2.7.2 直接内存内存溢出

public class Demo1_20 {
    static int _100Mb = 1024 * 1024 * 100;

    public static void main(String[] args) {
        List<ByteBuffer> list = new ArrayList<>();
        int i = 0;
        try {
            while (true) {
                ByteBuffer byteBuffer = ByteBuffer.allocateDirect(_100Mb);
                list.add(byteBuffer);
                i++;
            }
        } finally {
            System.out.println(i);
        }
    }
}
/*
26
Exception in thread "main" java.lang.OutOfMemoryError: Direct buffer memory
   at java.nio.Bits.reserveMemory(Bits.java:695)
   at java.nio.DirectByteBuffer.<init>(DirectByteBuffer.java:123)
   at java.nio.ByteBuffer.allocateDirect(ByteBuffer.java:311)
   at Unit1.Demo1_20.main(Demo1_20.java:21)
*/

2.7.3 直接内存释放原理

public class Demo1_21 {
    static int _1Gb = 1024 * 1024 * 1024;

    /*
     * -XX:+DisableExplicitGC 禁止显式的垃圾回收
     */
    public static void main(String[] args) throws IOException {
        ByteBuffer byteBuffer = ByteBuffer.allocateDirect(_1Gb);
        System.out.println("分配完毕...");
        System.in.read();
        System.out.println("开始释放...");
        byteBuffer = null;
        System.gc(); // 显式的垃圾回收，Full GC，影响性能
      	//unsafe.freeMemory(byteBuffer) 禁止显示垃圾回收后手动释放内存
        System.in.read();
    }
}

/**
 * 直接内存分配的底层原理：Unsafe
 */
public class Demo1_22 {
    static int _1Gb = 1024 * 1024 * 1024;

    public static void main(String[] args) throws IOException {
        Unsafe unsafe = getUnsafe();
        // 分配内存
        long base = unsafe.allocateMemory(_1Gb);
        unsafe.setMemory(base, _1Gb, (byte) 0);
        System.in.read();

        // 释放内存
        unsafe.freeMemory(base);
        System.in.read();
    }

    public static Unsafe getUnsafe() {
        try {
            Field f = Unsafe.class.getDeclaredField("theUnsafe");
            f.setAccessible(true);
            Unsafe unsafe = (Unsafe) f.get(null);
            return unsafe;
        } catch (NoSuchFieldException | IllegalAccessException e) {
            throw new RuntimeException(e);
        }
    }
}

• 使用了 Unsafe 对象完成直接内存的分配回收，并且回收需要主动调用 freeMemory 方法
• ByteBuffer 的实现类内部，使用了 Cleaner （虚引用）来监测 ByteBuffer 对象，一旦ByteBuffer 对象被垃圾回收，那么就会由 ReferenceHandler 线程通过 Cleaner 的 clean 方法调用 freeMemory 来释放直接内存

3. 垃圾回收

3.1 如何判断对象可以回收

3.1.1 引用计数法

所谓引用计数法，就是指一个对象只要被其他变量所引用，对象引用计数+1，如果某一个变量不再引用，那么引用计数-1，当引用计数变为0的时候，意味着就没有人再引用它了，就可以作为一个垃圾进行回收。

但是引用技术法存在一个重要的弊端

A对象引用B对象，B对象也引用了A对象，两个对象的引用计数都是1，虽然这两个对象都不能被使用了，但是它们两的引用计数都是1，无法当作垃圾进行回收，造成内存泄露。Python虚拟机早期使用这种方法，但JVM并不使用这种方法。

3.1.2 可达性分析算法

JVM判断对象是否是垃圾，采用可达性分析算法。

可达性分析算法首先要确定一系列根对象（肯定不能当作垃圾的对象我们称之为根对象）。在垃圾回收之前会先对堆内存中的所有对象进行一次扫描，看看每个对象是不是被根对象直接或间接引用，如果是那么这个对象就不能被回收，反之，如果一个对象没有被根对象直接或间接引用，那么这个对象就可以作为垃圾。

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

哪些对象可以作为 GC Root？

可以使用Eclipse提供的Memory Analyzer工具来查看哪些是根对象

Eclipse Memory Analyzer 内存分析器是一款快速且功能丰富的Java堆分析器，可以帮助您发现内存泄漏并减少内存消耗。使用内存分析器可以分析具有数亿个对象的生产性堆转储，快速计算对象的保留大小。查看谁在阻止垃圾收集器收集对象，运行报告以自动提取泄漏嫌疑人。

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

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

运行该程序后，看控制台输入以下命令：

PS D:\Code\In-depth_JavaSE\myJVM\src\main\java\Unit2> jps
13376 Launcher
18516 Demo2_1
21492 Jps
13340
PS D:\Code\In-depth_JavaSE\myJVM\src\main\java\Unit2> jmap -dump:format=b,live,file=1.bin 18516   #dump表示将状态存储为一个文件  b表示存储为二进制格式 live表示只关心存活对象，已经被回收的对象过滤掉，live会主动触发一次垃圾回收  file表示将快照存储为哪个文件
Dumping heap to D:\Code\In-depth_JavaSE\myJVM\src\main\java\Unit2\1.bin ...
Heap dump file created

抓取之后敲击回车，抓取第二个状态

PS D:\Code\In-depth_JavaSE\myJVM\src\main\java\Unit2> jmap -dump:format=b,live,file=2.bin 18516
Dumping heap to D:\Code\In-depth_JavaSE\myJVM\src\main\java\Unit2\2.bin ...
Heap dump file created

打开mat工具

同理，打开2.bin

3.1.3 四种引用

1. 强引用

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

2. 软引用（SoftReference）

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

3. 弱引用（WeakReference）

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

4. 虚引用（PhantomReference）

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

5. 终结器引用（FinalReference）

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

强引用演示

/**
 * 演示强引用
 * -Xmx20m -XX:+PrintGCDetails -verbose:gc
 */
public class Demo2_2 {
    private static final int _4MB = 4 * 1024 * 1024;

    public static void main(String[] args) throws IOException {
        List<byte[]> list = new ArrayList<>();
        for (int i = 0; i < 5; i++) {
            list.add(new byte[_4MB]);
        }
        System.in.read();
    }
}
/*
Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
*/

软引用演示

/**
 * 演示软引用
 * -Xmx20m -XX:+PrintGCDetails -verbose:gc
 */
public class Demo2_2 {
    private static final int _4MB = 4 * 1024 * 1024;

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

    public static void soft() {
        // list --> SoftReference --> byte[]
		//不再通过list直接引用byte数组，而是在它们直接加了SoftReference
      	//list先引用SoftReference，SoftReference再引用byte数组
        List<SoftReference<byte[]>> list = new ArrayList<>();
        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());
        }
    }
}

软引用垃圾回收详细参数

[B@7f31245a
1
[B@6d6f6e28
2
[B@135fbaa4
3
//第四次存放时内存不够用，进行垃圾回收，新生代内存 1898K->504K
[GC (Allocation Failure) [PSYoungGen: 1898K->504K(6144K)] 14186K->13019K(19968K), 0.0011016 secs] [Times: user=0.02 sys=0.00, real=0.02 secs] 
[B@45ee12a7
4
//前四次循环将内存占满
[GC (Allocation Failure) --[PSYoungGen: 4712K->4712K(6144K)] 17228K->17292K(19968K), 0.0007742 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[Full GC (Ergonomics) [PSYoungGen: 4712K->4502K(6144K)] [ParOldGen: 12579K->12534K(13824K)] 17292K->17036K(19968K), [Metaspace: 3364K->3364K(1056768K)], 0.0048974 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
//两次垃圾回收并没有回收多少，内存还是不够用，开始释放软引用
[GC (Allocation Failure) --[PSYoungGen: 4502K->4502K(6144K)] 17036K->17084K(19968K), 0.0006488 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[Full GC (Allocation Failure) [PSYoungGen: 4502K->0K(6144K)] [ParOldGen: 12582K->634K(8704K)] 17084K->634K(14848K), [Metaspace: 3364K->3364K(1056768K)], 0.0058596 secs] [Times: user=0.00 sys=0.02, real=0.01 secs] 
//将其他的软引用对象释放
[B@330bedb4
5
循环结束：5
null
null
null
null
[B@330bedb4
Heap
 PSYoungGen      total 6144K, used 4265K [0x00000000ff980000, 0x0000000100000000, 0x0000000100000000)
  eden space 5632K, 75% used [0x00000000ff980000,0x00000000ffdaa438,0x00000000fff00000)
  from space 512K, 0% used [0x00000000fff00000,0x00000000fff00000,0x00000000fff80000)
  to   space 512K, 0% used [0x00000000fff80000,0x00000000fff80000,0x0000000100000000)
 ParOldGen       total 8704K, used 634K [0x00000000fec00000, 0x00000000ff480000, 0x00000000ff980000)
  object space 8704K, 7% used [0x00000000fec00000,0x00000000fec9ea48,0x00000000ff480000)
 Metaspace       used 3373K, capacity 4500K, committed 4864K, reserved 1056768K
  class space    used 370K, capacity 388K, committed 512K, reserved 1048576K

软引用清除：在垃圾回收软引用后，list中留有null，没必要再保留

因此需要清理无用的软引用：

/**
 * 演示软引用, 配合引用队列
 */
public class Demo2_3 {
    private static final int _4MB = 4 * 1024 * 1024;

    public static void main(String[] args) {
        List<SoftReference<byte[]>> list = new ArrayList<>();

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

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

        // 从队列中获取无用的 软引用对象，并移除
        Reference<? extends byte[]> poll = queue.poll();
        while (poll != null) {
            list.remove(poll);
            poll = queue.poll();
        }

        System.out.println("===========================");
        for (SoftReference<byte[]> reference : list) {
            System.out.println(reference.get());
        }
    }
}
/*
[B@7f31245a
1
[B@6d6f6e28
2
[B@135fbaa4
3
[B@45ee12a7
4
[B@330bedb4
5
===========================
[B@330bedb4
*/

弱引用演示

/**
 * 演示弱引用
 * -Xmx20m -XX:+PrintGCDetails -verbose:gc
 */
public class Demo2_4 {
    private static final int _4MB = 4 * 1024 * 1024;

    public static void main(String[] args) {
        //  list --> WeakReference --> byte[]
        List<WeakReference<byte[]>> list = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            WeakReference<byte[]> ref = new WeakReference<>(new byte[_4MB]);
            list.add(ref);
            for (WeakReference<byte[]> w : list) {
                System.out.print(w.get()+" ");
            }
            System.out.println();

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

[B@7f31245a 
[B@7f31245a [B@6d6f6e28 
[B@7f31245a [B@6d6f6e28 [B@135fbaa4 
[GC (Allocation Failure) [PSYoungGen: 1898K->504K(6144K)] 14186K->12983K(19968K), 0.0062830 secs] [Times: user=0.00 sys=0.00, real=0.01 secs] 
[B@7f31245a [B@6d6f6e28 [B@135fbaa4 [B@45ee12a7 
[GC (Allocation Failure) [PSYoungGen: 4712K->504K(6144K)] 17192K->13055K(19968K), 0.0005917 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[B@7f31245a [B@6d6f6e28 [B@135fbaa4 null [B@330bedb4 
[GC (Allocation Failure) [PSYoungGen: 4712K->488K(6144K)] 17264K->13095K(19968K), 0.0004448 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[B@7f31245a [B@6d6f6e28 [B@135fbaa4 null null [B@2503dbd3 
[GC (Allocation Failure) [PSYoungGen: 4695K->504K(6144K)] 17303K->13127K(19968K), 0.0004218 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[B@7f31245a [B@6d6f6e28 [B@135fbaa4 null null null [B@4b67cf4d 
[GC (Allocation Failure) [PSYoungGen: 4710K->504K(6144K)] 17334K->13151K(19968K), 0.0005123 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[B@7f31245a [B@6d6f6e28 [B@135fbaa4 null null null null [B@7ea987ac 
[GC (Allocation Failure) [PSYoungGen: 4710K->496K(5120K)] 17358K->13207K(18944K), 0.0005196 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[B@7f31245a [B@6d6f6e28 [B@135fbaa4 null null null null null [B@12a3a380 
[GC (Allocation Failure) [PSYoungGen: 4682K->32K(5632K)] 17393K->13159K(19456K), 0.0004868 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[Full GC (Ergonomics) [PSYoungGen: 32K->0K(5632K)] [ParOldGen: 13127K->652K(8192K)] 13159K->652K(13824K), [Metaspace: 3363K->3363K(1056768K)], 0.0057838 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
null null null null null null null null null [B@29453f44 
循环结束：10
Heap
 PSYoungGen      total 5632K, used 4278K [0x00000000ff980000, 0x0000000100000000, 0x0000000100000000)
  eden space 4608K, 92% used [0x00000000ff980000,0x00000000ffdadb18,0x00000000ffe00000)
  from space 1024K, 0% used [0x00000000ffe00000,0x00000000ffe00000,0x00000000fff00000)
  to   space 1024K, 0% used [0x00000000fff00000,0x00000000fff00000,0x0000000100000000)
 ParOldGen       total 8192K, used 652K [0x00000000fec00000, 0x00000000ff400000, 0x00000000ff980000)
  object space 8192K, 7% used [0x00000000fec00000,0x00000000feca3160,0x00000000ff400000)
 Metaspace       used 3373K, capacity 4500K, committed 4864K, reserved 1056768K
  class space    used 369K, capacity 388K, committed 512K, reserved 1048576K

full GC才会把所有的弱引用进行垃圾回收

3.2 垃圾回收算法

3.2.1 标记清除

定义： Mark Sweep

特点：

• 速度较快
• 会造成内存碎片

3.2.2 标记整理

定义：Mark Compact

特点：

• 速度慢
• 没有内存碎片

3.2.3 复制

定义：Copy

特点：

• 不会有内存碎片
• 需要占用双倍内存空间

3.3 分代垃圾回收

实际JVM虚拟机不会采用一种垃圾回收算法，都是结合三种垃圾回收算法协同工作。具体实现通过分代垃圾回收机制实现。将堆内存分为两块：新生代和老年代。新生代又分为伊甸园、幸存区FROM、幸存区TO。

我们根据对象生命周期的不同特点，把长时间使用的对象放在老年代中，那些用完就丢弃的对象放在新生代。

也就是新生代的垃圾可以快速回收，而老年代的垃圾存活较久。

**当我们创建一个对象，首先会采用伊甸园的一块空间，将对象存入伊甸园；当创建的对象较多，伊甸园的空间不够用的时候，就会触发一次垃圾回收，我们把新生代的垃圾回收称作Minor GC，Minor GC触发以后，就会执行可达性分析算法，分辨对象是否为垃圾并进行标记，标记成功后采用复制算法，将存活的对象（GC ROOT）复制到幸存区TO中，并且让幸存的对象寿命+1（初始寿命为0），再将伊甸园的没用的对象（垃圾）回收，再交换幸存区FROM和幸存区TO的位置；这时就可以继续向伊甸园分配新的对象，经过一段时间后伊甸园又满了，触发第二次垃圾回收，这次垃圾回收除了要把伊甸园中存活的对象找到，还要把幸存区中存活的对象找到，把这些对象放入幸存区TO，且幸存对象寿命+1，再将伊甸园和幸存区FROM中的垃圾回收，幸存区FROM和幸存区TO交换位置；幸存区中的对象并不会永远在幸存区呆着，当其寿命超过一个阈值，就会将其晋升到老年代中。当新生代已满，且老年代也满，就会触发垃圾回收：Full GC，对两代都进行一次清理。 **

• 对象首先分配在伊甸园区域
• 新生代空间不足时，触发 minor gc，伊甸园和 from 存活的对象使用 copy 复制到 to 中，存活的对象年龄加 1并且交换幸存区 from to
• minor gc 会引发 stop the world，暂停其它用户的线程，等垃圾回收结束，用户线程才恢复运行
• 当对象寿命超过阈值时，会晋升至老年代，最大寿命是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
幸存区比例	-XX:SurvivorRatio=ratio
晋升阈值	-XX:MaxTenuringThreshold=threshold
晋升详情	-XX:+PrintTenuringDistribution
GC详情	-XX:+PrintGCDetails -verbose:gc
FullGC 前 MinorGC	-XX:+ScavengeBeforeFullGC

GC分析

/**
 *  演示内存的分配策略
 *  -Xms20M -Xmx20M -Xmn10M -XX:+UseSerialGC -XX:+PrintGCDetails -verbose:gc 
 *  -XX:-ScavengeBeforeFullGC
 */
public class Demo2_5 {
    private static final int _512KB = 512 * 1024;
    private static final int _1MB = 1024 * 1024;
    private static final int _6MB = 6 * 1024 * 1024;
    private static final int _7MB = 7 * 1024 * 1024;
    private static final int _8MB = 8 * 1024 * 1024;

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

添加参数后运行：

Heap
//新生代
 def new generation   total 9216K, used 2009K [0x00000000fec00000, 0x00000000ff600000, 0x00000000ff600000)
  //伊甸园 因为启动Java程序有自身的类，所以占用了24%
  eden space 8192K,  24% used [0x00000000fec00000, 0x00000000fedf6498, 0x00000000ff400000)
  //幸存区FROM
  from space 1024K,   0% used [0x00000000ff400000, 0x00000000ff400000, 0x00000000ff500000)
  //幸存区TO
  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 3226K, capacity 4496K, committed 4864K, reserved 1056768K
  class space    used 354K, capacity 388K, committed 512K, reserved 1048576K

创建一个7M的对象

ArrayList<byte[]> list = new ArrayList<>();
list.add(new byte[_7MB]);

//[minor GC [新生代: 回收前->回收后(总大小),垃圾回收耗费时间] 整个堆的回收前内存占用->整个堆的回收后内存占用(整个堆的总大小), 整个堆的垃圾回收所用时间] 
[GC (Allocation Failure) [DefNew: 2013K->652K(9216K), 0.0013691 secs] 2013K->652K(19456K), 0.0014134 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
Heap
 def new generation   total 9216K, used 8066K [0x00000000fec00000, 0x00000000ff600000, 0x00000000ff600000)
  eden space 8192K,  90% used [0x00000000fec00000, 0x00000000ff33d8c0, 0x00000000ff400000)
  from space 1024K,  63% used [0x00000000ff500000, 0x00000000ff5a3120, 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 3369K, capacity 4496K, committed 4864K, reserved 1056768K
  class space    used 369K, capacity 388K, committed 512K, reserved 1048576K

再放一个512K的数组

[GC (Allocation Failure) [DefNew: 2013K->627K(9216K), 0.0019820 secs] 2013K->627K(19456K), 0.0020514 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
Heap
 def new generation   total 9216K, used 8717K [0x00000000fec00000, 0x00000000ff600000, 0x00000000ff600000)
  eden space 8192K,  98% used [0x00000000fec00000, 0x00000000ff3e6840, 0x00000000ff400000)
  from space 1024K,  61% used [0x00000000ff500000, 0x00000000ff59cf10, 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 3369K, capacity 4496K, committed 4864K, reserved 1056768K
  class space    used 369K, capacity 388K, committed 512K, reserved 1048576K

再放一个512K的数组

[GC (Allocation Failure) [DefNew: 2013K->652K(9216K), 0.0012200 secs] 2013K->652K(19456K), 0.0012736 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
//第二次Minor GC
[GC (Allocation Failure) [DefNew: 8496K->512K(9216K), 0.0050287 secs] 8496K->8310K(19456K), 0.0050667 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
Heap
 def new generation   total 9216K, used 1269K [0x00000000fec00000, 0x00000000ff600000, 0x00000000ff600000)
  eden space 8192K,   9% used [0x00000000fec00000, 0x00000000fecbd4d8, 0x00000000ff400000)
  from space 1024K,  50% used [0x00000000ff400000, 0x00000000ff480048, 0x00000000ff500000)
  to   space 1024K,   0% used [0x00000000ff500000, 0x00000000ff500000, 0x00000000ff600000)
 tenured generation   total 10240K, used 7798K [0x00000000ff600000, 0x0000000100000000, 0x0000000100000000)
//一部分对象（很容易看出是7M的对象）晋升老年代
   the space 10240K,  76% used [0x00000000ff600000, 0x00000000ffd9daa0, 0x00000000ffd9dc00, 0x0000000100000000)
 Metaspace       used 3369K, capacity 4496K, committed 4864K, reserved 1056768K
  class space    used 369K, capacity 388K, committed 512K, reserved 1048576K

大对象：直接晋升老年代

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

由于新生代放不下一个大小为8M的对象，不会触发GC，会直接晋升为老年代

Heap
 def new generation   total 9216K, used 2177K [0x00000000fec00000, 0x00000000ff600000, 0x00000000ff600000)
  eden space 8192K,  26% used [0x00000000fec00000, 0x00000000fee20648, 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 3368K, capacity 4496K, committed 4864K, reserved 1056768K
  class space    used 369K, capacity 388K, committed 512K, reserved 1048576K

当放两个8M的对象时就会出现堆内存溢出

[GC (Allocation Failure) [DefNew: 2013K->625K(9216K), 0.0016347 secs][Tenured: 8192K->8816K(10240K), 0.0017904 secs] 10205K->8816K(19456K), [Metaspace: 3312K->3312K(1056768K)], 0.0035016 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[Full GC (Allocation Failure) [Tenured: 8816K->8798K(10240K), 0.0015910 secs] 8816K->8798K(19456K), [Metaspace: 3312K->3312K(1056768K)], 0.0016207 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
Heap
 def new generation   total 9216K, used 410K [0x00000000fec00000, 0x00000000ff600000, 0x00000000ff600000)
  eden space 8192K,   5% used [0x00000000fec00000, 0x00000000fec66800, 0x00000000ff400000)
  from space 1024K,   0% used [0x00000000ff500000, 0x00000000ff500000, 0x00000000ff600000)
  to   space 1024K,   0% used [0x00000000ff400000, 0x00000000ff400000, 0x00000000ff500000)
 tenured generation   total 10240K, used 8798K [0x00000000ff600000, 0x0000000100000000, 0x0000000100000000)
   the space 10240K,  85% used [0x00000000ff600000, 0x00000000ffe979e8, 0x00000000ffe97a00, 0x0000000100000000)
 Metaspace       used 3379K, capacity 4496K, committed 4864K, reserved 1056768K
  class space    used 370K, capacity 388K, committed 512K, reserved 1048576K
Exception in thread "main" java.lang.OutOfMemoryError: Java heap space 
	at Unit2.Demo2_5.main(Demo2_5.java:22)  //Java 堆内存溢出

如果这段代码运行在一个线程，那么这个线程并不影响主线程

public static void main(String[] args) throws InterruptedException {
    new Thread(() -> {
        ArrayList<byte[]> list = new ArrayList<>();
        list.add(new byte[_8MB]);
        list.add(new byte[_8MB]);
        //list.add(new byte[_8MB]);
    }).start();

    System.out.println("sleep....");
    Thread.sleep(1000000000L);
}

sleep....
[GC (Allocation Failure) [DefNew: 4079K->857K(9216K), 0.0027624 secs][Tenured: 8192K->9047K(10240K), 0.0044443 secs] 12271K->9047K(19456K), [Metaspace: 4263K->4263K(1056768K)], 0.0072877 secs] [Times: user=0.00 sys=0.00, real=0.01 secs] 
[Full GC (Allocation Failure) [Tenured: 9047K->8991K(10240K), 0.0036930 secs] 9047K->8991K(19456K), [Metaspace: 4263K->4263K(1056768K)], 0.0037322 secs] [Times: user=0.00 sys=0.00, real=0.01 secs] 
Exception in thread "Thread-0" java.lang.OutOfMemoryError: Java heap space
	at Unit2.Demo2_5.lambda$main$0(Demo2_5.java:23)
	at Unit2.Demo2_5$$Lambda$1/1023892928.run(Unknown Source)
	at java.lang.Thread.run(Thread.java:750)
Heap
 def new generation   total 9216K, used 1555K [0x00000000fec00000, 0x00000000ff600000, 0x00000000ff600000)
  eden space 8192K,  18% used [0x00000000fec00000, 0x00000000fed84db8, 0x00000000ff400000)
  from space 1024K,   0% used [0x00000000ff500000, 0x00000000ff500000, 0x00000000ff600000)
  to   space 1024K,   0% used [0x00000000ff400000, 0x00000000ff400000, 0x00000000ff500000)
 tenured generation   total 10240K, used 8991K [0x00000000ff600000, 0x0000000100000000, 0x0000000100000000)
   the space 10240K,  87% used [0x00000000ff600000, 0x00000000ffec7f00, 0x00000000ffec8000, 0x0000000100000000)
 Metaspace       used 4779K, capacity 4912K, committed 4992K, reserved 1056768K
  class space    used 534K, capacity 592K, committed 640K, reserved 1048576K

线程内的堆内存溢出，不影响主线程的运行

3.4 垃圾回收器

1. 串行

• 单线程
• 堆内存较小，适合个人电脑

2. 吞吐量优先

• 多线程
• 堆内存较大，多核 cpu
• 让单位时间内，STW 的时间最短 0.2 0.2 = 0.4，垃圾回收时间占比最低，这样就称吞吐量高（单位时间内回收的垃圾多）

3. 响应时间优先

• 多线程
• 堆内存较大，多核 cpu
• 尽可能让单次 STW 的时间最短 0.1 0.1 0.1 0.1 0.1 = 0.5

3.4.1 串行垃圾回收器

打开串行垃圾回收器：-XX:+UseSerialGC = Serial + SerialOld

串行垃圾回收器分为两部分，Serial和SerialOld，Serial工作在新生代，采用复制算法；SerialOld工作在老年代，采用标记整理算法。

在执行垃圾回收之前，先让所有的线程到达一个安全点停下（STW）（因为在垃圾回收过程中，对象的地址可能发生改变），再进行垃圾回收。

3.4.2 吞吐量优先垃圾回收器

开启吞吐量优先垃圾回收器：-XX:+UseParallelGC ~ -XX:+UseParallelOldGC（只要开启一个，两个都会开启）

在Java8中默认开启，Java8中默认使用ParallelGC（并行的垃圾回收器）

ParallelGC是新生代的垃圾回收器，采用复制算法；ParallelOldGC是老年代的垃圾回收器，采用标记整理算法。

单从算法上来看，都不产生内存碎片，而此回收器采用并行。

多核CPU，4个线程都在运行，这时内存不足，触发垃圾回收，用户线程就会跑到安全点停下来，垃圾回收器开启多个线程进行垃圾回收。

垃圾回收器线程的个数默认和CPU核数相关。因此在垃圾回收的时候CPU占用率就会变高。

线程数可以通过-XX:ParallelGCThreads=n参数进行控制

ParallelGC的一个特点是可以根据目标进行调整，设置ParallelGC的工作方式

• -XX:+UseAdaptiveSizePolicy：采用新生代大小自适应调整策略

• -XX:GCTimeRatio=ratio：调整吞吐量的目标

  1/(1+ratio)

  ratio的默认值为99

  1/100 = 0.01

  即垃圾回收的时间不能超过总时间的1%（0.01）

  如果达不到这个目标，ParallelGC就会调整堆的大小来达到目标（一般是将堆增大，堆增大，垃圾回收次数就不频繁了）

• -XX:MaxGCPauseMillis=ms：最大暂停毫秒数

  默认值为200ms

  MaxGCPauseMillis与GCTimeRatio=ratio是冲突的，因为调整了GCTimeRatio意味着堆会变大，堆变大，吞吐量提升，那么每一次垃圾回收所花费的时间就会增长，可能就无法达到MaxGCPauseMillis的指标。

3.4.3 响应时间优先垃圾回收器

开启响应时间优先垃圾回收器：-XX:+UseConcMarkSweepGC -XX:+UseParNewGC SerialOld

concMarkSweep：并发标记清除垃圾回收

并发和并行垃圾回收的本质区别是有没有用户线程与垃圾回收线程同时进行

ConcMarkSweepGC是工作在老年代的一款GC，与之配合的ParNewGC是工作在新生代的基于复制算法的GC

CMSGC有时会发生并发失败的问题，这时就会采取补救措施，让老年代的ConcMarkSweepGC退化到SerialOld串行垃圾回收器

• 多个CPU开始并行执行，老年代发生了内存不足，线程到达安全点暂停，CMSGC会执行初始标记，在执行初始标记的时候任然需要STW
• 当初始标记完成后，所有线程到达安全点，用户线程恢复运行，与此同时垃圾回收线程进行并发标记，将剩余的垃圾找到
• 并发标记完成到达安全点，进行重新标记，这时会STW
• 重新标记后所有线程到达安全点，用户线程恢复运行，垃圾回收线程进行并发清理，之后回复运行

并发时线程数收到下面两个参数的影响：

• -XX:ParallelGCThreads=n -XX:ConcGCThreads=threads

  并行垃圾回收线程数 一般与CPU核数有关 并发垃圾回收线程一般设置为并行垃圾回收线程数的1/4

• -XX:CMSInitiatingOccupancyFraction=percent

  CMSGC在工作过程中执行并发清理时，由于其他用户线程还可以继续运行，而这些用户线程运行时可能又会产生新的垃圾，并发清理不能把这些新的垃圾回收，因此需要等到下次垃圾回收时再清理这些新垃圾，这些新垃圾称之为浮动垃圾，需要预留一些空间保留浮动垃圾。CMSInitiatingOccupancyFraction是控制何时进行CMS垃圾回收的。CMSInitiatingOccupancyFraction译为执行CMS的内存占比，percent即为内存占比。假设percent为80%，当老年代内存到达80%时，就执行一次垃圾回收。这样就预留了空间给浮动垃圾使用。在早期JVM默认值为65%左右。

• -XX:+CMSScavengeBeforeRemark

  在重新标记阶段，新生代的对象有可能引用老年代的对象，这时如果重新标记，必须扫描整个堆，这样对性能影响比较严重，因为新生代创建的对象比较多，而且其中很多是必须作为垃圾的。CMSScavengeBeforeRemark可以在重新标记之前进行一次新生代的垃圾回收(UseParNewGC)。这样在重新标记前扫描的对象就少了，可以减轻重新标记时的压力。

3.5 G1

G1垃圾回收器，即 Garbage First

发展历史：

• 2004 论文发布
• 2009 JDK 6u14 体验
• 2012 JDK 7u4 官方支持
• 2017 JDK 9 默认（在JDK9中废弃了CMSGC）

适用场景：

• 同时注重吞吐量（Throughput）和低延迟（Low latency），默认的暂停目标是 200 ms

  G1（读作 Garbage One），它同时注重吞吐量和低延迟，它的内部也是基于这种并发的，它也是一种
  属于并发的垃圾回收器，跟之前提到的 CMS 在某些目标上是一致的，它追求的是低延迟，可以在用户
  线程工作的同时，垃圾回收线程也并发的去执行，另外它也借鉴了之前的 Parallel 那种注重吞吐量的
  垃圾回收器的一些思想：它可以进行一个调整，你可以设置一个目标，比如说它默认的一个暂停目标就是通过 -XX:MaxGCPauseMillis=time这样一个参数来设置一个暂停目标，默认是200ms。从这个设置的暂停目标值来看，它确实追求的是一种低延迟，当然如果吞吐量对你的应用程序更为重要，可以把这个暂停目标提高一些，提升吞吐量。这是第一个应用场景。

• 超大堆内存，会将堆划分为多个大小相等的 Region

  第二个就是，它适合超大的堆内存，现在随着硬件的不断发展，内存也越来越大，尤其是服务器内存可以使用的内存量越来越大。有一篇评测，G1 跟 CMS 都属于这种并发的垃圾回收器，在堆内存较小的这种场景下，它俩其实速度上或者说暂停时间上其实是不相上下的，但是如果随着堆内存的容量越来越大，那么 G1 的优势就特别明显了，就比 CMS 暂停时间更领先。G1对超大堆内存管理的思想就是把这个堆划分成了多个大小相等的 Region（区域），把整个堆内存划分成大小相等的区域，每个区域都可以独立的作为伊甸园、幸存区还有老年代，有一个相关的参数叫 -XX:G1HeapRegionSize=size，可以设置区域的大小，设置这个区域必须设成1 / 2 / 4 / 8 / 16 这样的大小，其实从这可以想象到，如果堆内存过大，那肯定是回收速度越来越慢，因为要涉及到对象的复制包括标记，内存大确实会对这两项速度都会造成影响，而把它分成小的区域来进行管理，化整为零，这样就可以进行一些优化，加快它的标记包括拷贝的速度。

• 整体上是标记+整理算法，两个区域之间是复制算法

  G1在整体上使用的是标记整理算法，它可以避免之前 CMS 垃圾回收器的那种标记清除算法产生的内存碎片问题，但是它两个区域之间（两个 Region 之间）用的是复制算法。

相关JVM参数：

• -XX:+UseG1GC JDK9之后不需要显示启动
• -XX:G1HeapRegionSize=size 设置堆区域大小
• -XX:MaxGCPauseMillis=time 最大暂停毫秒数

G1垃圾回收阶段

新生代垃圾收集 ---> 新生代垃圾收集+并发标记 ---> 混合收集（收集整个新生代和部分老年代的垃圾）

网上对G1的回收阶段有不同的说法，参考Oracle JVM工程师的一个说法：他把整个 G1 的垃圾回收阶段分成了三个，第一个叫 Young Collection，是对新生代的垃圾收集，第二个阶段叫 Young Collection + Concurrent Mark，是新生代的垃圾收集同时会执行一些并发的标记，第三个阶段呢叫 Mixed Collection 混合收集。这三个阶段呢是一个循环的过程，刚开始是新生代的垃圾收集，经过一段时间，当老年代的内存超过一个阈值，它会在新生代垃圾收集的同时呢进行并发的标记，等这个阶段完成了以后，会进行一个混合收集，混合收集会对新生代、幸存区和老年代都进行一个规模较大的一次收集，等内存释放掉了，混合收集结束，这时候伊甸园的内存都被释放掉，它会再次进入新生代的一个垃圾收集过程

我们详细看一下每个阶段它的工作流程

3.5.1 新生代回收

Young Collection

我们会将堆划分为多个大小相等的区（Region），而每个区域都可以作为伊甸园、幸存区、老年代

• 开始所有区都是空的，创建一些对象就会分配到伊甸园
• 工作一段时间，伊甸园逐渐被占满，就会触发一次新生代的垃圾回收（触发STW，时间相对较短），将幸存对象用复制算法放入幸存区
• 一段时间后幸存区对象较多，且幸存区对象存活超过了一定时间，就会触发新生代的垃圾回收，幸存区的一部分对象就会晋升到老年代，剩余年龄不够的拷贝到另一个幸存区。

图中标有E的绿色区域就是伊甸园，图中标有S的蓝色区域就是幸存区，图中标有O的橙色区域就是老年代

3.5.2 新生代回收+CM

Young Collection + CM

G1 垃圾回收的第二个阶段，叫做新生代的垃圾回收和并发标记阶段，这里的 CM 就是指Concurrent Mark，就是并发标记的意思。

我们进行垃圾回收的过程中要对这些对象进行初始标记和并发标记；初始标记就是找到那些根对象，标记那些根对象，而并发标记是从根对象出发，顺着它的引用链去标记其它的对象

初始标记在 Young GC 时就发生了，Young GC STW的时候就对这些根对象会做一个初始标记，所以初始标记不会占用并发标记的时间，它仅仅发生在新生代的垃圾回收时，

那么什么时候会进行并发标记呢，它是等老年代占用的堆空间比例达到一定的阈值时，这时候会发生并发标记，并发标记跟 CMS 的并发标记类似，它是并发执行的，在标记的同时呢，不会影响到用户的工作线程，也就是不会 STW，这个阈值可以通过JVM的参数来进行一个控制，它的默认值是45%，就是整个老年代占用到整个堆空间的大约45%时，它就会进行这个并发标记了。

• 在 Young GC 时会进行 GC Root 的初始标记

• 老年代占用堆空间比例达到阈值（默认45%）时，进行并发标记（不会 STW），由下面的 JVM 参数决定

  -XX:InitiatingHeapOccupancyPercent=percent

图中标有E的绿色区域就是伊甸园，图中标有S的蓝色区域就是幸存区，图中标有O的橙色区域就是老年代

3.5.3 混合回收

Mixed Collection

G1 垃圾回收时的第三个阶段，叫做 Mixed Collection 混合收集，在混合收集阶段，会对伊甸园、幸存区、老年代这三个区域进行一个全面的垃圾回收。

我们可以参考图片来更好的理解

• E 是伊甸园区，它的幸存对象会被复制算法复制到幸存区中去，另一些幸存区中的幸存对象不够年龄的也会复制到这个幸存区，一些符合晋升条件的对象，会晋升到老年代的区域，这些都是属于Mixed Collection阶段新生代的回收
  *经过了之前的并发标记阶段，发现老年代区域里面有些对象已经没用了，而这个时候的老年代是采用了复制算法从旧的老年代区域把幸存对象复制到新的老年代的区域。那为什么没有把所有老年代幸存的对象都复制到新的老年代区域呢？是因为这个时候 G1 垃圾回收器会根据最大暂停时间去选择性的进行一个回收；有的时候堆内存的空间太大了，这时候老年代的垃圾回收时间可能比较长，因为是复制算法，大量的对象要从一个区域复制到另外一个区域，这个时间较长就达不到之前设置的 MaxGCPauseMillis 最大暂停时间的目标。为了达到这个目标， G1 就会从这些老年代里挑出回收价值最高的几个区域，也就是G1认为这几个区域如果回收了释放的空间比较多，这样只挑其中一部分区域来进行垃圾回收，复制的区域少了，自然就可以达到暂停时间的目标，需要的垃圾回收时间就相对变短。如果要复制的对象不多，暂停时间目标也可以达到，G1就会把所有老年代区域都进行一个复制，复制一方面是为了保留存活对象，另一方面是为了整理内存，减少空间碎片

为什么官方把这个垃圾收集器叫做 Garbage First：在混合收集的阶段对老年代的这些区域来讲，它优先要回收那些垃圾最多的区域，主要的目的就是为了达到暂停时间短的目标

不管在混合收集的哪个阶段，最终标记还有拷贝存活这两个阶段都会 STW。

之前并发标记的过程中可能会漏掉一些对象，并发标记的同时其他的用户线程也在工作，可能会产生一些新的垃圾改变一些对象的引用，这样会对并发标记的结果产生影响，所以需要在混合收集的阶段先 STW，然后去执行一个最终标记，最终标记完成了，就把存活的对象进行拷贝，这个拷贝的过程对老年代的拷贝来讲并不是所有的老年代都会发生拷贝动作，只会回收那些垃圾最多的老年代区域。

3.5.4 Full GC

到目前为止，已经学习了很多垃圾回收器了，有串行、并行，还有 CMS 和 G1 都称之为并发的垃圾回收器。

它们有一些共同特点：它们在新生代内存不足时，触发的垃圾收集都可以称之 Minor GC。

串行的和并行的垃圾收集器，它们由于老年代内存不足触发的垃圾收集我们称之 Full GC。

但是对于 CMS 和 G1 稍微有些不一样，它们的老年代内存不足触发的垃圾收集还要分两种情况。以 G1 为例来进行说明，G1 垃圾收集器老年代内存不足有一个阈值，当老年代内存跟整个堆内存内存占比达到45%（默认值）以上的时候，就会触发一个并发标记的阶段，以及后续混合收集的阶段，这两个阶段工作的过程中，如果回收速度是高于新用户线程产生垃圾的速度的时候，也就是回收速度比产生新垃圾的速度快，来得及打扫，这个时候还不叫 Full GC，这时还是处于并发垃圾收集的阶段，虽然重新标记和数据拷贝的过程还会有暂停，但是这个暂停时间还是相对很短的。

那 G1在什么时候才会发生 Full GC呢，就是当垃圾回收的速度跟不上垃圾产生的速度，这个时候并发收集就失败了，和 CMS 类似，这时候就会退化成串行收集，这时的串行收集就是Full GC，更长时间的 STW 导致响应时间变长。 CMS 当然也是一样，并发失败以后是 Full GC，如果并发没有失败时还处于并发收集阶段，也不会出现 Full GC。判断依据可以看GC 日志，GC日志里打印出 Full GC的字样，才叫做 Full GC。 CMS 和G1如果是工作在并发收集的阶段回收速度高于垃圾产生速度，后台的回收日志里是不会有 Full GC的字样的。

• SerialGC
  • 新生代内存不足发生的垃圾收集 - minor gc
  • 老年代内存不足发生的垃圾收集 - full gc
• ParallelGC
  • 新生代内存不足发生的垃圾收集 - minor gc
  • 老年代内存不足发生的垃圾收集 - full gc
• CMS
  • 新生代内存不足发生的垃圾收集 - minor gc
  • 老年代内存不足
• G1
  • 新生代内存不足发生的垃圾收集 - minor gc
  • 老年代内存不足

3.5.5 新生代跨代引用

新生代垃圾回收的过程，首先是要找到根对象，然后通过根对象，可达性分析，再找到存活对象，存活对象进行复制，复制到幸存区。这里就有一个问题，要找新生代对象的根对象，就要通过根对象进行查找，而根对象有一部分是来自于老年代的，通常老年代存活对象非常多，如果遍历整个老年代，找这个根对象，显然效率是非常低的。

因此采用一种卡表的技术，把老年代的区域再进行一个细分，分成了一个个的小的Card，每个小的Card呢大概是512k，如果这个老年代其中有一个对象引用了新生代的对象那么对应的Card我们就把它标记为脏Card，这样的话好处就是，在 GC Root遍历的时候，不用去找整个老年代了，而是只需要去关注那些脏Card区域，其实就是减少搜索范围，提高扫描根对象的效率。

新生代里有一个Remembered Set,记录了外部哪个Card引用，然后通过Remembered Set把这个Card标记为脏
Card,减少了遍历找GC Root的时间

图中粉红色的区域就是脏Card区域，它们其中都有对象引用了另外Region，也就是新生代Region中的对象。新生代这边会有 Remembered Set，它会记录从外部对它的一些引用，也就是记录都有哪些脏Card，将来去对新生代做垃圾回收时，就可以先通过 Remembered Set 知道它对应哪些脏Card，然后再到这些脏Card去遍历 GC Root，这样减少了GC Root的遍历时间。

这里就有一个问题，标记这些脏Card，是通过一个叫post - write barrier 这样一个写屏障，在每次对象的引用发生变更时他都要去更新这个脏Card，就把 Crad Table中的 Card 标记为脏Card，这是一个异步操作，它不会立刻去完成脏Card的更新，它会把这个更新的指令放在脏Card的队列之中，将来由一个线程去完成脏Card的更新操作，在新生代垃圾回收时跨代引用时就利用了这种Card Table和 Remembered Set 的技术来加速了新生代的垃圾回收。

• 卡表与 Remembered Set
• 在引用变更时通过 post-write barrier + dirty card queue
• concurrent refinement threads 更新 Remembered Set

3.5.6 Remark

CMS 和 G1 这些并发垃圾回收器，都提到了它们有这两个阶段，一个阶段叫并发标记阶段，另外一个叫重新标记阶段，即本节的 Remark 这个阶段，对于 Remark 阶段，之前没有详细地说明，现在我们来看一下Remark。

这张图表示的是并发标记阶段时对象的一个处理状态，其中图里这种黑色的表示已经处理完成的，并且它们都是有引用在引用它们，所以黑色的将来是表示在结束时，被保留下来，会存活下来的对象，灰色的呢是正在处理当中的，而白色的是尚未处理的，当然，上图是一个中间状态。

如果最后都处理完成了，那上图灰色的因为有强引用在引用着它，所以它最终会变成黑色，也就是它还是会存活，灰色右边的白色因为也有引用在引用它，因此它也会存活，最后也会变成黑色存活下来。至于上面的白色因为没有人引用它了，它最终还是白色，它就会被当成垃圾回收。也就是等我们垃圾回收结束时会根据对象的黑白这个状态来区分它到底是应该存活还是应该当成垃圾。

这张图呢还是刚才那三种状态，分别是黑色：已经处理完，灰色：尚在处理中，白色：还没有处理到它，现在我们
思考一个问题，比如说我处理到了这个灰色的这个B对象，然后因为有强引用引用着它，所以把它变成黑色，将来会存活，但是等我处理到C的时候，注意这是一个并发标记，并发标记就意味着它同时呢会有用户的线程对这个对象的引用做修改。

如果把B和C的引用给断掉，那处理B的时候接下来该处理C了，它发现C跟B之间已经没有联系了，所以处理到C的时候它就会进行一个标记：C将来是白色的，等整个并发标记结束以后，C对象由于它仍然是白色，最后就会被当成垃圾回收掉。

我们可以考虑另外一种情况，如果在C被处理完了以后，并发标记可能还没有结束，这时候用户线程又改变了C的引用地址，比如说它又把C对象当成是A对象的一个属性做了一次复制操作，C的引用又发生了改变，因为C之前已经处理过了，他认为已经是白色的，那A又是黑色的，以后不会处理它了，因为认为它处理过了，所以等到整个并发标记结束以后，C就被漏了，我们仍然认为C是白色的，是垃圾，就要把它回收掉，但这样就不对了，这时候有一个强引用引用着它，再把它回收掉就不合理了，所以我们要对对象的引用做进一步地检查，就是我们刚刚提到的Remark重新标记阶段，就是为了防止这样的现象发生的。

Remark重新标记具体做法是这样的：当对象的引用发生改变时，JVM就会给它加入一个写屏障，什么叫写屏障呢，就是只要对象引用发生了改变，这个写屏障的代码就会被执行。比如说我们刚才把C的引用作为A的其中一个属性，这说明C的引用发生了变化，既然发生了变化，那么写屏障的指令就会被执行。写屏障指令干了些什么事，它就会把这个C加入到一个队列当中，并且把C变成灰色，表示它还没有处理完，等到整个并发标记结束了，接下来进入重新标记阶段，重新标记会 STW，让其它的用户线程都暂停，这个时候重新标记的线程就会把队列中的对象一个一个取出来，再做一次检查，如果发现是灰色的，那还要对它进行进一步的判断、处理，结果又发现有强引用引用着它，因此还应该把它变成黑色，这样的话就不会让C对象被误当成垃圾回收掉了。

以上就是在Remark阶段做的事情。它是pre-write barrier写屏障技术在对象引用改变前把这个对象加入到了一个队列，并且表示它是未被处理的，这个队列的名称叫 satb_mark_queue，将来的 Remark阶段就可以配合这个队列来对这些对象进行进一步的判断，以上就是重标记阶段的一些相关知识。

• pre-write barrier + satb_mark_queue

接下来介绍一些 G1 垃圾回收器它的一些优化，它的优化是在持续进行中，这里只介绍一些从 JDK8 开始的优化到
JDK 9，至于更新的优化呢，这里没有赘述。

3.5.7 字符串去重

-XX:+UseStringDeduplication 默认启用

• 优点：节省大量内存
• 缺点：略微多占用了 cpu 时间，新生代回收时间略微增加

在 JDk8u 20 这个版本中，它实现了一个字符串去重功能，我们来思考这么一个问题：

String s1 = new String("hello"); //char[]{'h', 'e', 'l', 'l', 'o'}
String s2 = new String("hello"); //char[]{'h', 'e', 'l', 'l', 'o'}

看上面两行代码，它都是用new关键字创建了两个值相同的String对象，在 JDK8 中字符串它的底层是使用了char[]数组来存储每一个字符，比如说 "hello" 这个字符串它的底层就是char[]数组，里面有'h', 'e', 'l', 'l', 'o' 这几个字符，现在new了两个字符串，但实际上这个char[]数组的也是有两个，显然如果我们有大量创建新字符串的动作，这个字符串对内存的占用是相当可观的，那能想到的一种办法：我们可以用之前介绍过的 intern() 方法来实现一个去重，但是除此以外 G1 这个垃圾回收器它又引出了一种新的办法，它会将所有新分配的字符串放入一个队列，然后在新生代垃圾回收时，它就会并发的去检查这个队列中新创建的字符串是不是跟已有的字符串有重复，如果它们的值是一样的，那会让它们引用一个相同的char[]，意思就是s1字符串原本引用的是后边的char[]数组，在垃圾回收并发检查的阶段，它就会让s1引用下面的char[]数组，让s2也引用下面的char[]数组，这样的话虽然是两个字符串对象，但是它底层的char[]数组是同一个。

原理就是让两个字符串对象引用同一个char[]数组，但是要注意它和String.intern() 是不太一样的，String.intern() 关注的是字符串对象，它是让字符串对象本身不重复，它使用了一个StringTable来去重，但是G1这种字符串去重技术，关注的是char[]数组，它俩在JVM内部使用的是不同的字符串表。当然要开启这个字符串去重功能需要需要打开一个开关：-XX:+UseStringDeduplication，这个开关是默认打开的，优点是会节省大量的内存，缺点呢它会略微多占用一些cpu的时间，因为它是在新生代发生的去重检查，所以它会让新生代的垃圾回收时间略微的增加，但是在总的性能上来看，它带来的收益还是远远高于它占用的cpu时间和新生代的垃圾回收的时间的。

• 将所有新分配的字符串放入一个队列
• 当新生代回收时，G1 并发检查是否有字符串重复
• 如果它们值一样，让它们引用同一个 char[]
• 注意，与String.intern() 不一样
  • String.intern() 关注的是字符串对象
  • 而字符串去重关注的是 char[]
  • 在 JVM内部，（String.intern()和G1的去重）使用了不同的字符串表

3.5.8 类卸载

JDK 8u40 并发标记类卸载

所有对象都经过并发标记后，就能知道哪些类不再被使用，当一个类加载器的所有类都不再使用，则卸载它所加载的所有类

-XX:+ClassUnloadingWithConcurrentMark 默认启用

这里介绍在 JDK 8u40 这个更新中对 G1 垃圾回收器它的一个功能增强， 这个功能增强叫做并发标记时的类卸载，在我们之前的 JDK 版本中，这个类一般是没办法卸载的，只要加载了以后，它就会一直占用着内存，其实有的时候很多自定义的类加载器创建和加载类使用过一段时间以后其实就没人再用了，这个时候如果还让他们占用着内存，其实对垃圾回收也是不利的。

从 8u40 这个版本开始，G1 它就会做这样一件事：在所有对象经过并发标记阶段以后，它就能知道哪些类不再被使用了，这时候它就会尝试去执行一个类卸载的操作，当然这个卸载条件比较苛刻一些，首先这个类它们的实例都被回收掉，第二就是这个类所在的类加载器其中的所有类都不再使用了，这时候它就会把这个类加载器里面所有的类全部卸载掉。虽然这个条件苛刻了一些，但是如果是对一些框架程序，这些框架程序很多都使用了自定义的类加载器，那么这种情况还是会发生的，就是一个类加载中所有类还有所有类它们的实例全部没人用了，那它就可以把它全部卸载掉。

当然 JDK 的这些类加载器它们加载类是一般不会卸载的，因为 JDK 的类加载器就是启动类加载器还有扩展类加载器还有应用程序类加载器，它们都是始终会存在的，不会类卸载，只是对于我们自定义的类加载器才会这种类卸载的功能和需求，通过 -XX:+ClassUnloadingWithConcurrentMark 这个参数就可以让这个卸载功能启用，这是默认启用的。

3.5.9 巨型对象

在 JDK 8u60 这个版本中，对 G1 的功能进行了一项增强，这个增强呢就是可以让它回收巨型对象，在 G1它的区域划分中一共有四种区域，伊甸园区、幸存区、老年代区，其实还有一种就是巨型对象区域，这个巨型对象它的一个条件默认的是当一个对象它的大小大于整个Region的一半的时候，我们就可以把它称之为巨型对象。

这个巨型对象它在内存中的分布，它也许会占到更多的区域，比如图中下面的巨型对象占用了两个Region，上面的巨型对象占用了三个Region，这称之为巨型对象。那巨型对象它的垃圾回收其实要跟其他的普通对象的垃圾回收要进行一个区分，因为巨型对象它要进行拷贝这个代价是比较高的，所以 G1 不会对巨型对象进行拷贝，并且回收时也会优先回收这个巨型对象，他对巨型对象的回收有一些优化的处理。

G1 会跟踪从老年代到巨型对象中的所有 incoming 引用，当老年代的 incoming 引用为0时，老年代有 Card Table，只要老年代中的 Card Table 中的某个card引用了这个巨型对象，那这个 Card 也会标记为脏的，显然图片中上面的巨型对象从老年代出发对它的引用是两个，下面的巨型对象从老年代的脏Card中出发，它的引用有三个，当某个巨型对象从老年代的引用为0时，没有人再从老年代引用它了，那它就可以在新生代的垃圾回收时被回收掉了。总的意思就是希望巨型对象越早回收越好，最好就在新生代的垃圾回收时就把它处理掉。

• 一个对象大于Region的一半时，称之为巨型对象
• G1 不会对巨型对象进行拷贝
• 回收时被优先考虑
• G1 会跟踪老年代所有 incoming 引用，这样老年代 incoming 引用为 0 的巨型对象就可以在新生代垃圾回收时处理掉

3.5.10 动态调整阈值

JDK 9 中对 G1 垃圾回收器又有很多的功能增强，其中一项比较重要的是它并发标记时间的调整，G1 面临一个 Full GC 的问题，如果垃圾回收它的速度跟不上垃圾产生的速度，最终它也是会退化为 Full GC 的。

在现在这个 G1 的版本中，即使是 Full GC，也早已变成了多线程，Full GC 它 STW 的时间肯定更长，所以我们还是要尽可能地避免 Full GC 的发生，那怎么去减少 Full GC 的情况呢？我们可以让垃圾回收提前开始，让我们的并发标记，混合收集提前开始，这样就能够减少 Full GC 发生的几率，在 JDK 9 之前，我们要设置这样一个参数：-XX:InitiatingHeapOccupancyPercent，这个参数就是指老年代内存跟整个堆内存的占比阈值，当超过这个阈值的时候它这个并发的垃圾回收就开始了，这个阈值默认是45%，但 JDK 9 以后，发现有的时候如果把这个阈值固定了它其实就不太好了，定的大了容易产生 Full GC，定的小了又频繁的去做并发标记和混合收集，因此 JDK 9 里它可以去动态地调整这个阈值，也就是我们刚刚的参数仅仅是用来设置了一个初始值，比如说我们初始默认是45%，但是它后面在垃圾回收的过程中可以对数据进行采样并且动态调整阈值，可以把这个阈值调大调小，总之它会添加一个安全的空挡空间。让这个堆的空闲空间总够的大，容纳那些浮动的垃圾，这样呢就可以尽可能的避免并发垃圾回收退化成 Full GC 的垃圾回收了。

• 并发标记必须在堆内存占满前完成，否则退化为 Full GC
• JDK 9 之前需要使用 -XX:InitiatingHeapOccupancyPercent
• JDK 9 可以动态调整
  • -XX:InitiatingHeapOccupancyPercent 用来设置初始值
  • 进行数据采样并动态调整
  • 总会添加一个安全的空挡空间

3.6 垃圾回收调优

预备知识

• 掌握 GC 相关的 VM 参数，会基本的空间调整

  -XX:+PrintFlagsFinal -version findstr "GC" 可以查看JVM运行参数

• 掌握相关工具如jmap、jconsole、mat等

• 调优跟应用、环境有关，没有放之四海而皆准的法则

3.6.1 调优领域

• 内存
• 锁竞争
• cpu 占用
• io

确定目标：

• 【低延迟】还是【高吞吐量】，选择合适的回收器
  • 低延迟（相应时间优先）：CMS，G1，ZGC（Java12体验）
  • 高吞吐量：ParallelGC
  • Zing虚拟机：据说使用的GC零停，还可以管理超大内存

3.6.2 最快的GC是不发生GC

• 查看 FullGC 前后的内存占用，考虑下面几个问题

  • 数据是不是太多？

    加载了不必要的数据到内存，内存数据太多，导致GC频繁

    如resultSet = statement.executeQuery("select * from 大表 limit n")

  • 数据表示是否太臃肿？

    • 对象图

    • 对象大小

      new 一个Object最小都要占16个字节

      最常用的Integer要占24个字节

  • 是否存在内存泄漏？

    常见错误：static Map map 不断向map集合中存放对象，又不移除，导致内存溢出OutOfMemory

    对于长时间存活的对象建议使用

    • 软引用
    • 弱引用
    • 第三方缓存实现：Redis

3.6.3 新生代调优

• 新生代的特点

  • 所有的 new 操作的内存分配非常廉价

    TLAB thread-local allocation buffer 线程局部分配缓冲区

    通过TLAB，在伊甸园中创建对象是非常快的

  • 死亡对象的回收代价是零

  • 新生代大部分对象用过即死

  • Minor GC 的时间远远低于 Full GC

新生代的内存越大越好吗？

-Xmn 设置新生代的初始和最大值

Sets the initial and maximum size (in bytes) of the heap for the young generation (nursery). GC isperformed in this region more often than in other regions. If the size for the young generation istoo small, then a lot of minor garbage collections are performed. If the size is too large, then onlyfull garbage collections are performed, which can take a long time to complete. Oraclerecommends that you keep the size for the young generation greater than 25% and less than50% of the overall heap size.

为新生代设置堆的初始大小和最大大小(以字节为单位)。
新生代进行GC检查的频率高于其他地区。
如果新生代的大小太小，则会执行许多次要的垃圾收集。
如果大小太大，则只执行完整的垃圾回收，这可能需要很长时间才能完成。
Oracle建议您将新生代的大小保持在总堆大小的25%和50%以下。

• 新生代能容纳所有【并发量 * (请求-响应)】的数据

• 幸存区大到能保留【当前活跃对象+需要晋升对象】

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

  -XX:MaxTenuringThreshold=threshold 调整最大晋升阈值
  -XX:+PrintTenuringDistribution 打印晋升详细信息

  Desired survivor size 48286924 bytes, new threshold 10 (max 10)
  - age 1: 28992024 bytes, 28992024 total
  - age 2: 1366864 bytes, 30358888 total
  - age 3: 1425912 bytes, 31784800 total
  ...
  

3.6.4 老年代调优

以 CMS 为例

• CMS 的老年代内存越大越好

  预留更多的空间，避免浮动垃圾过多，导致并发失败

• 先尝试不做调优，如果没有 Full GC 就不需要进行调优。如果发生了Full GC，应该先尝试调优新生代

• 观察发生 Full GC 时老年代内存占用，将老年代内存预设调大 1/4 ~ 1/3

  -XX:CMSInitiatingOccupancyFraction=percent 控制老年代达到总内存多少时进行垃圾回收，百分比越低，触发垃圾回收的时机就越早

3.6.5 案例

• 案例1 Full GC 和 Minor GC频繁
• 案例2 请求高峰期发生 Full GC，单次暂停时间特别长 （CMS）
• 案例3 老年代充裕情况下，发生 Full GC （CMS jdk1.7）

4. 类加载与字节码技术

4.1 类文件结构

下面是一个简单的HelloWorld

public class HelloWorld{
        public static void main(String[] args){
                System.out.println("Hello World");
        }
}

执行 javac -parameters -d . HelloWorld.java

编译后的HelloWorld.class是这样子的

[root@localhost myjava]# od -t xC HelloWorld.class 
#八进制标号   字节码内容
0000000 ca fe ba be 00 00 00 37 00 1f 0a 00 06 00 11 09
0000020 00 12 00 13 08 00 14 0a 00 15 00 16 07 00 17 07
0000040 00 18 01 00 06 3c 69 6e 69 74 3e 01 00 03 28 29
0000060 56 01 00 04 43 6f 64 65 01 00 0f 4c 69 6e 65 4e
0000100 75 6d 62 65 72 54 61 62 6c 65 01 00 04 6d 61 69
0000120 6e 01 00 16 28 5b 4c 6a 61 76 61 2f 6c 61 6e 67
0000140 2f 53 74 72 69 6e 67 3b 29 56 01 00 10 4d 65 74
0000160 68 6f 64 50 61 72 61 6d 65 74 65 72 73 01 00 04
0000200 61 72 67 73 01 00 0a 53 6f 75 72 63 65 46 69 6c
0000220 65 01 00 0f 48 65 6c 6c 6f 57 6f 72 6c 64 2e 6a
0000240 61 76 61 0c 00 07 00 08 07 00 19 0c 00 1a 00 1b
0000260 01 00 0b 48 65 6c 6c 6f 20 57 6f 72 6c 64 07 00
0000300 1c 0c 00 1d 00 1e 01 00 0a 48 65 6c 6c 6f 57 6f
0000320 72 6c 64 01 00 10 6a 61 76 61 2f 6c 61 6e 67 2f
0000340 4f 62 6a 65 63 74 01 00 10 6a 61 76 61 2f 6c 61
0000360 6e 67 2f 53 79 73 74 65 6d 01 00 03 6f 75 74 01
0000400 00 15 4c 6a 61 76 61 2f 69 6f 2f 50 72 69 6e 74
0000420 53 74 72 65 61 6d 3b 01 00 13 6a 61 76 61 2f 69
0000440 6f 2f 50 72 69 6e 74 53 74 72 65 61 6d 01 00 07
0000460 70 72 69 6e 74 6c 6e 01 00 15 28 4c 6a 61 76 61
0000500 2f 6c 61 6e 67 2f 53 74 72 69 6e 67 3b 29 56 00
0000520 21 00 05 00 06 00 00 00 00 00 02 00 01 00 07 00
0000540 08 00 01 00 09 00 00 00 1d 00 01 00 01 00 00 00
0000560 05 2a b7 00 01 b1 00 00 00 01 00 0a 00 00 00 06
0000600 00 01 00 00 00 01 00 09 00 0b 00 0c 00 02 00 09
0000620 00 00 00 25 00 02 00 01 00 00 00 09 b2 00 02 12
0000640 03 b6 00 04 b1 00 00 00 01 00 0a 00 00 00 0a 00
0000660 02 00 00 00 03 00 08 00 04 00 0d 00 00 00 05 01
0000700 00 0e 00 00 00 01 00 0f 00 00 00 02 00 10
0000716

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

ClassFile {
//字节数		  
  u4 			magic;		//魔数
  u2 			minor_version;		//小版本号
  u2 			major_version;		//主版本号
  u2 			constant_pool_count;		//常量池
  cp_			info constant_pool[constant_pool_count-1];
  u2 			access_flags;		//访问修饰
  u2 			this_class;			//类的信息
  u2 			super_class;		//父类信息
  u2 			interfaces_count;	//接口信息
  u2 			interfaces[interfaces_count];
  u2 			fields_count;		//类中成员变量
  field_info 	 fields[fields_count];
  u2 			methods_count;		//方法信息
  method_info 	 methods[methods_count];
  u2 			attributes_count;	//类的附加属性信息
  attribute_info attributes[attributes_count];
}

4.1.1 魔数

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

0000000 ca fe ba be 00 00 00 37 00 1f 0a 00 06 00 11 09

cafebabe：咖啡宝贝 表示是class类型的文件

4.1.2 版本

4~7 字节，表示类的版本 00 37（55） 表示是 Java 11

00 34（52）表示 Java 8

0000000 ca fe ba be 00 00 00 37 00 1f 0a 00 06 00 11 09

4.1.3 常量池

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

0000000 ca fe ba be 00 00 00 37 00 1f 0a 00 06 00 11 09

Constant Type	Value
CONSTANT_Class	7
CONSTANT_Fieldref	9
CONSTANT_Methodref	10
CONSTANT_InterfaceMethodref	11
CONSTANT_String	8
CONSTANT_Integer	3
CONSTANT_Float	4
CONSTANT_Long	5
CONSTANT_Double	6
CONSTANT_NameAndType	12
CONSTANT_Utf8	1
CONSTANT_MethodHandle	15
CONSTANT_MethodType	16
CONSTANT_InvokeDynamic	18

• 第#1项 0a（10） 表示一个 Method 信息，00 06 和 00 11（17） 表示它引用了常量池中 #6 和 #17 项来获得这个方法的【所属类】和【方法名】

  0000000 ca fe ba be 00 00 00 37 00 1f 0a 00 06 00 11 09

• 第#2项 09 表示一个 Field 信息，00 12（18）和 00 13（19） 表示它引用了常量池中 #18 和 # 19 项来获得这个成员变量的【所属类】和【成员变量名】

  0000000 ca fe ba be 00 00 00 37 00 1f 0a 00 06 00 11 09

  0000020 00 12 00 13 08 00 14 0a 00 15 00 16 07 00 17 07

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

  0000020 00 12 00 13 08 00 14 0a 00 15 00 16 07 00 17 07

• 第#4项 0a 表示一个 Method 信息，00 19（25） 和 00 1a（26） 表示它引用了常量池中 #25 和 #26项来获得这个方法的【所属类】和【方法名】

  0000020 00 12 00 13 08 00 14 0a 00 15 00 16 07 00 17 07

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

  0000020 00 12 00 13 08 00 14 0a 00 15 00 16 07 00 17 07

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

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

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

• 第#7项 01 表示一个 utf8 串，00 06 表示长度，3c 69 6e 69 74 3e 是【<init> 】

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

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

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

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

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

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

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

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

  0000100 75 6d 62 65 72 54 61 62 6c 65 01 00 04 6d 61 69

• 第#11项 01 表示一个 utf8 串，00 04（04） 表示长度，6d 61 69 6e 01 00 16 28 5b 4c 6a 61 76 61 2f 6c 61 6e是【LocalVariableTable】

  0000100 75 6d 62 65 72 54 61 62 6c 65 01 00 04 6d 61 69

  0000120 6e 01 00 16 28 5b 4c 6a 61 76 61 2f 6c 61 6e 67

......

4.2 字节码指令

自己分析类构造文件结构很麻烦，Orcale提供了javap工具来反编译class文件

PS D:\Code\In-depth_JavaSE\myJVM\target\classes\Unit3> javap -v HelloWorld.class
Classfile /D:/Code/In-depth_JavaSE/myJVM/target/classes/Unit3/HelloWorld.class
  Last modified 2022年11月15日; size 544 bytes
  MD5 checksum 8ce858a7bcf565f89ab791e17dd4e2ac
  Compiled from "HelloWorld.java"
public class Unit3.HelloWorld
  minor version: 0
  major version: 52
  flags: (0x0021) ACC_PUBLIC, ACC_SUPER
  this_class: #5                          // Unit3/HelloWorld
  super_class: #6                         // java/lang/Object
  interfaces: 0, fields: 0, methods: 2, attributes: 1
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            // HelloWorld
   #4 = Methodref          #24.#25        // java/io/PrintStream.println:(Ljava/lang/String;)V
   #5 = Class              #26            // Unit3/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               LUnit3/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               HelloWorld
  #24 = Class              #31            // java/io/PrintStream
  #25 = NameAndType        #32:#33        // println:(Ljava/lang/String;)V
  #26 = Utf8               Unit3/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 Unit3.HelloWorld();
    descriptor: ()V
    flags: (0x0001) 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 9: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       5     0  this   LUnit3/HelloWorld;

  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: (0x0009) 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 HelloWorld
         5: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
         8: return
      LineNumberTable:
        line 11: 0
        line 12: 8
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       9     0  args   [Ljava/lang/String;
}
SourceFile: "HelloWorld.java"

4.2.1 图解方法执行流程

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

编译后的字节码文件

PS D:\Code\In-depth_JavaSE\myJVM\target\classes\Unit3> javap -v Demo3_1.class
Classfile /D:/Code/In-depth_JavaSE/myJVM/target/classes/Unit3/Demo3_1.class
  Last modified 2022年11月15日; size 595 bytes
  MD5 checksum ea1e3e51de207562bc5a29e8b5ab0dc5
  Compiled from "Demo3_1.java"
public class Unit3.Demo3_1
  minor version: 0
  major version: 52
  flags: (0x0021) ACC_PUBLIC, ACC_SUPER
  this_class: #6                          // Unit3/Demo3_1
  super_class: #7                         // java/lang/Object
  interfaces: 0, fields: 0, methods: 2, attributes: 1
Constant pool:
   #1 = Methodref          #7.#25         // java/lang/Object."<init>":()V
   #2 = Class              #26            // java/lang/Short
   #3 = Integer            32768
   #4 = Fieldref           #27.#28        // java/lang/System.out:Ljava/io/PrintStream;
   #5 = Methodref          #29.#30        // java/io/PrintStream.println:(I)V
   #6 = Class              #31            // Unit3/Demo3_1
   #7 = Class              #32            // java/lang/Object
   #8 = Utf8               <init>
   #9 = Utf8               ()V
  #10 = Utf8               Code
  #11 = Utf8               LineNumberTable
  #12 = Utf8               LocalVariableTable
  #13 = Utf8               this
  #14 = Utf8               LUnit3/Demo3_1;
  #15 = Utf8               main
  #16 = Utf8               ([Ljava/lang/String;)V
  #17 = Utf8               args
  #18 = Utf8               [Ljava/lang/String;
  #19 = Utf8               a
  #20 = Utf8               I
  #21 = Utf8               b
  #22 = Utf8               c
  #23 = Utf8               SourceFile
  #24 = Utf8               Demo3_1.java
  #25 = NameAndType        #8:#9          // "<init>":()V
  #26 = Utf8               java/lang/Short
  #27 = Class              #33            // java/lang/System
  #28 = NameAndType        #34:#35        // out:Ljava/io/PrintStream;
  #29 = Class              #36            // java/io/PrintStream
  #30 = NameAndType        #37:#38        // println:(I)V
  #31 = Utf8               Unit3/Demo3_1
  #32 = Utf8               java/lang/Object
  #33 = Utf8               java/lang/System
  #34 = Utf8               out
  #35 = Utf8               Ljava/io/PrintStream;
  #36 = Utf8               java/io/PrintStream
  #37 = Utf8               println
  #38 = Utf8               (I)V
{
  public Unit3.Demo3_1();
    descriptor: ()V
    flags: (0x0001) ACC_PUBLIC
    Code:
      stack=1, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
         4: return
      LineNumberTable:
        line 6: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       5     0  this   LUnit3/Demo3_1;

  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: (0x0009) ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=4, args_size=1
         0: bipush        10
         2: istore_1
         3: ldc           #3                  // int 32768
         5: istore_2
         6: iload_1
         7: iload_2
         8: iadd
         9: istore_3
        10: getstatic     #4                  // Field java/lang/System.out:Ljava/io/PrintStream;
        13: iload_3
        14: invokevirtual #5                  // Method java/io/PrintStream.println:(I)V
        17: return
      LineNumberTable:
        line 8: 0
        line 9: 3
        line 10: 6
        line 11: 10
        line 12: 17
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      18     0  args   [Ljava/lang/String;
            3      15     1     a   I
            6      12     2     b   I
           10       8     3     c   I
}
SourceFile: "Demo3_1.java"

• 常量池载入运行时常量池

  

  运行时常量池其实是方法区的一部分，为了方便演示，这里将其分出来。

  Class文件存储的数据存储在运行时常量池

  一些比较小的数字并不是存储在常量池中，而是和方法的字节码指令存储在一起。当数字超过了Short的最大值，就会存储在常量池中。

  Short的最大值是32767 因此#3中的Integet存放32768

• 方法字节码载入方法区

• main 线程开始运行，分配栈帧内存

  （stack=2，locals=4）

• 执行引擎开始执行字节码

  • bipush 10
    将一个 byte 压入操作数栈（其长度会补齐 4 个字节），类似的指令还有

    • sipush 将一个 short 压入操作数栈（其长度会补齐 4 个字节）
    • ldc 将一个 int 压入操作数栈
    • ldc2_w 将一个 long 压入操作数栈（分两次压入，因为 long 是 8 个字节）
    • 这里小的数字都是和字节码指令存在一起，超过 short 范围的数字存入了常量池

  

  • istore_1

    将操作数栈顶数据弹出，存入局部变量表的 slot 1

    

    将操作数栈顶的10弹出到局部变量表中的位置1 对应java代码中 a=10 的操作

  • ldc #3

    从常量池加载 #3 数据到操作数栈

    注意 Short.MAX_VALUE 是 32767，所以 32768 = Short.MAX_VALUE + 1 实际是在编译期间计算好的

    

  • istore_2

    给b变量赋值

    

    

  • iload_1

    执行a+b要将变量放入操作数栈中进行计算

    

  • iload_2

    

  • iadd

    ​ 执行加法计算

    

  • istore_3

    给c赋值

    

  • getstatic #4

    到常量池中找到成员变量的引用，将System.out的引用地址放入操作数栈中

    

  

  • iload_3

    

  • invokevirtual #5

    • 找到常量池 #5 项
    • 定位到方法区 java/io/PrintStream.println:(I)V 方法
    • 生成新的栈帧（分配 locals、stack等）
    • 传递参数，执行新栈帧中的字节码

    

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

    

  • return

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

    程序结束

4.2.2 从字节码角度分析 a++相关题目

题目源码：

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

字节码：

PS D:\Code\In-depth_JavaSE\myJVM\target\classes\Unit3> javap -v Demo3_2.class
Classfile /D:/Code/In-depth_JavaSE/myJVM/target/classes/Unit3/Demo3_2.class
  Last modified 2022年11月15日; size 570 bytes
  MD5 checksum 1514058e8378a98e310cda6777ec32eb
  Compiled from "Demo3_2.java"
public class Unit3.Demo3_2
  minor version: 0
  major version: 52
  flags: (0x0021) ACC_PUBLIC, ACC_SUPER
  this_class: #4                          // Unit3/Demo3_2
  super_class: #5                         // java/lang/Object
  interfaces: 0, fields: 0, methods: 2, attributes: 1
Constant pool:
   #1 = Methodref          #5.#22         // java/lang/Object."<init>":()V
   #2 = Fieldref           #23.#24        // java/lang/System.out:Ljava/io/PrintStream;
   #3 = Methodref          #25.#26        // java/io/PrintStream.println:(I)V
   #4 = Class              #27            // Unit3/Demo3_2
   #5 = Class              #28            // java/lang/Object
   #6 = Utf8               <init>
   #7 = Utf8               ()V
   #8 = Utf8               Code
   #9 = Utf8               LineNumberTable
  #10 = Utf8               LocalVariableTable
  #11 = Utf8               this
  #12 = Utf8               LUnit3/Demo3_2;
  #13 = Utf8               main
  #14 = Utf8               ([Ljava/lang/String;)V
  #15 = Utf8               args
  #16 = Utf8               [Ljava/lang/String;
  #17 = Utf8               a
  #18 = Utf8               I
  #19 = Utf8               b
  #20 = Utf8               SourceFile
  #21 = Utf8               Demo3_2.java
  #22 = NameAndType        #6:#7          // "<init>":()V
  #23 = Class              #29            // java/lang/System
  #24 = NameAndType        #30:#31        // out:Ljava/io/PrintStream;
  #25 = Class              #32            // java/io/PrintStream
  #26 = NameAndType        #33:#34        // println:(I)V
  #27 = Utf8               Unit3/Demo3_2
  #28 = Utf8               java/lang/Object
  #29 = Utf8               java/lang/System
  #30 = Utf8               out
  #31 = Utf8               Ljava/io/PrintStream;
  #32 = Utf8               java/io/PrintStream
  #33 = Utf8               println
  #34 = Utf8               (I)V
{
  public Unit3.Demo3_2();
    descriptor: ()V
    flags: (0x0001) ACC_PUBLIC
    Code:
      stack=1, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
         4: return
      LineNumberTable:
        line 6: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       5     0  this   LUnit3/Demo3_2;

  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: (0x0009) ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=3, args_size=1
         0: bipush        10
         2: istore_1
         3: iload_1
         4: iinc          1, 1
         7: iinc          1, 1
        10: iload_1
        11: iadd
        12: iload_1
        13: iinc          1, -1
        16: iadd
        17: istore_2
        line 8: 0
        line 9: 3
        line 10: 18
        line 11: 25
        line 12: 32
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      33     0  args   [Ljava/lang/String;
            3      30     1     a   I
           18      15     2     b   I
}
SourceFile: "Demo3_2.java"

分析：

• 执行自增指令为iinc。注意 iinc 指令是直接在局部变量 slot 上进行运算

• a++ 和 ++a 的区别是先执行 iload 还是 先执行 iinc

  a=10

​ 先执行iload，加载a到操作数栈

​ iinc 执行i++

​ iinc 执行i++

​ iload 加载i到操作数栈

​ 执行相加操作：i++ + ++i

​ iload 将i加载到操作数栈中

​ 执行i--

​ 执行i++ + ++i - i--

​ 将结果赋值给b

4.2.3 条件判断指令

指令	助记符	含义
0x99	ifeq	判断是否 == 0
0x9a	ifne	判断是否 != 0
0x9b	iflt	判断是否 < 0
0x9c	ifge	判断是否 >= 0
0x9d	ifgt	判断是否 > 0
0x9e	ifle	判断是否 <= 0
0x9f	if_icmpeq	两个int是否 ==
0xa0	if_icmpne	两个int是否 !=
0xa1	if_icmplt	两个int是否 <
0xa2	if_icmpge	两个int是否 >=
0xa3	if_icmpgt	两个int是否 >
0xa4	if_icmple	两个int是否 <=
0xa5	if_acmpeq	两个引用是否 ==
0xa6	if_acmpne	两个引用是否 !=
0xc6	ifnull	判断是否 == null
0xc7	ifnonnull	判断是否 != null

几点说明：

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

4.2.4 构造方法

1. <cinit>()V

   是整个类的构造方法

   public class Demo3_3 {
       static int i = 10;
   
       static {
           i = 20;
       }
   
       static {
           i = 30;
       }
   }
   

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

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

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

2. <init>()V

   是实例对象的构造方法

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

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

   public cn.itcast.jvm.t3.bytecode.Demo3_8_2(java.lang.String, int);
   descriptor: (Ljava/lang/String;I)V
   flags: ACC_PUBLIC
   Code:
   stack=2, locals=3, args_size=3
   0: aload_0
   1: invokespecial #1 // super.<init>()V
   4: aload_0
   5: ldc #2 // <- "s1"
   7: putfield #3 // -> this.a
   10: aload_0
   11: bipush 20 // <- 20
   13: putfield #4 // -> this.b
   16: aload_0
   17: bipush 10 // <- 10
   19: putfield #4 // -> this.b
   22: aload_0
   23: ldc #5 // <- "s2"
   25: putfield #3 // -> this.a
   28: aload_0 	// -------------------------------
   29: aload_1 	// <- slot 1(a) "s3" 			|
   30: putfield #3 // -> this.a 					|
   33: aload_0 								   |
   34: iload_2 // <- slot 2(b) 30 				     |
   35: putfield #4 // -> this.b ----------------------
   38: return
   LineNumberTable: ...
   LocalVariableTable:
   Start Length Slot Name Signature
   0 39 0 this Lcn/itcast/jvm/t3/bytecode/Demo3_8_2;
   0 39 1 a Ljava/lang/String;
   0 39 2 b I
   MethodParameters: ...
   

   执行顺序：静态代码块 -> 非静态代码块 -> 类的构造函数

   4.2.5 方法调用

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

   public class Demo3_5 {
       public Demo3_5() {
       }
   
       private void test1() {
       }
   
       private final void test2() {
       }
   
       public void test3() {
       }
   
       public static void test4() {
       }
   
       public static void main(String[] args) {
           Demo3_5 d = new Demo3_5();
           d.test1();
           d.test2();
           d.test3();
           d.test4();
           Demo3_5.test4();
       }
   }
   

   Classfile /D:/Code/In-depth_JavaSE/myJVM/target/classes/Unit3/Demo3_5.class
     Last modified 2022年11月15日; size 733 bytes
     MD5 checksum 5dd67a9c799127f0815fd047c785c9e5
     Compiled from "Demo3_5.java"
   public class Unit3.Demo3_5
     minor version: 0
     major version: 52
     flags: (0x0021) ACC_PUBLIC, ACC_SUPER
     this_class: #2                          // Unit3/Demo3_5
     super_class: #8                         // java/lang/Object
     interfaces: 0, fields: 0, methods: 6, attributes: 1
   Constant pool:
      #1 = Methodref          #8.#27         // java/lang/Object."<init>":()V
      #2 = Class              #28            // Unit3/Demo3_5
      #3 = Methodref          #2.#27         // Unit3/Demo3_5."<init>":()V
      #4 = Methodref          #2.#29         // Unit3/Demo3_5.test1:()V
      #5 = Methodref          #2.#30         // Unit3/Demo3_5.test2:()V
      #6 = Methodref          #2.#31         // Unit3/Demo3_5.test3:()V
      #7 = Methodref          #2.#32         // Unit3/Demo3_5.test4:()V
      #8 = Class              #33            // java/lang/Object
      #9 = Utf8               <init>
     #10 = Utf8               ()V
     #11 = Utf8               Code
     #12 = Utf8               LineNumberTable
     #13 = Utf8               LocalVariableTable
     #14 = Utf8               this
     #15 = Utf8               LUnit3/Demo3_5;
     #16 = Utf8               test1
     #17 = Utf8               test2
     #18 = Utf8               test3
     #19 = Utf8               test4
     #20 = Utf8               main
     #21 = Utf8               ([Ljava/lang/String;)V
     #22 = Utf8               args
     #23 = Utf8               [Ljava/lang/String;
     #24 = Utf8               d
     #25 = Utf8               SourceFile
     #26 = Utf8               Demo3_5.java
     #27 = NameAndType        #9:#10         // "<init>":()V
     #28 = Utf8               Unit3/Demo3_5
     #29 = NameAndType        #16:#10        // test1:()V
     #30 = NameAndType        #17:#10        // test2:()V
     #31 = NameAndType        #18:#10        // test3:()V
     #32 = NameAndType        #19:#10        // test4:()V
     #33 = Utf8               java/lang/Object
   {
     public Unit3.Demo3_5();
       descriptor: ()V
       flags: (0x0001) 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
           line 5: 4
         LocalVariableTable:
           Start  Length  Slot  Name   Signature
               0       5     0  this   LUnit3/Demo3_5;
   
     public void test3();
       descriptor: ()V
       flags: (0x0001) ACC_PUBLIC
       Code:
         stack=0, locals=1, args_size=1
            0: return
         LineNumberTable:
           line 14: 0
         LocalVariableTable:
           Start  Length  Slot  Name   Signature
               0       1     0  this   LUnit3/Demo3_5;
   
     public static void test4();
       descriptor: ()V
       flags: (0x0009) ACC_PUBLIC, ACC_STATIC
       Code:
         stack=0, locals=0, args_size=0
            0: return
         LineNumberTable:
           line 17: 0
   
     public static void main(java.lang.String[]);
       descriptor: ([Ljava/lang/String;)V
       flags: (0x0009) ACC_PUBLIC, ACC_STATIC
       Code:
         stack=2, locals=2, args_size=1
            0: new           #2                  // class Unit3/Demo3_5 在对空间分配内存，分配成功就把引用地址放入操作数栈	
            3: dup								//将栈顶的元素复制一份
            4: invokespecial #3                  // Method "<init>":()V 根据栈顶元素调用构造方法
            7: astore_1						//出栈
            8: aload_1							//入栈
            9: invokespecial #4                  // Method test1:()V
           12: aload_1
           13: invokespecial #5                  // Method test2:()V
           16: aload_1
           17: invokevirtual #6                  // Method test3:()V
         LocalVariableTable:
           Start  Length  Slot  Name   Signature
               0      29     0  args   [Ljava/lang/String;
               8      21     1     d   LUnit3/Demo3_5;
   }
   SourceFile: "Demo3_5.java"
   
   

   • new 是创建【对象】，给对象分配堆内存，执行成功会将【对象引用】压入操作数栈
   • dup 是赋值操作数栈栈顶的内容，本例即为【对象引用】，为什么需要两份引用呢，一个是要配合invokespecial 调用该对象的构造方法 "<init>"😦)V （会消耗掉栈顶一个引用），另一个要配合 astore_1 赋值给局部变量
   • 最终方法（final），私有方法（private），构造方法都是由 invokespecial 指令来调用，属于静态绑定
     普通成员方法是由 invokevirtual 调用，属于动态绑定，即支持多态
   • 成员方法与静态方法调用的另一个区别是，执行方法前是否需要【对象引用】
   • 比较有意思的是 d.test4(); 是通过【对象引用】调用一个静态方法，可以看到在调用invokestatic 之前执行了 pop 指令，把【对象引用】从操作数栈弹掉了😂
   • 还有一个执行 invokespecial 的情况是通过 super 调用父类方法

4.2.5 多态的原理

/**
 * 演示多态原理，注意加上下面的 JVM 参数，禁用指针压缩
 * -XX:-UseCompressedOops -XX:-UseCompressedClassPointers
 */
public class Demo3_6 {
    public static void test(Animal animal) {
        animal.eat();
        System.out.println(animal.toString());
    }

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

abstract class Animal {
    public abstract void eat();

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

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

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

• 运行代码

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

• 运行 HSDB 工具

  进入 JDK 安装目录，执行 java -cp ./lib/sa-jdi.jar sun.jvm.hotspot.HSDB

• 进入图形界面 attach 进程 id

• 查找某个对象

  • 打开 Tools -> Find Object By Query
  • 输入 select d from cn.itcast.jvm.t3.bytecode.Dog d 点击 Execute 执行

• 查看对象内存结构

  点击超链接可以看到对象的内存结构，此对象没有任何属性，因此只有对象头的 16 字节，前 8 字节是MarkWord，后 8 字节就是对象的 Class 指针

  但目前看不到它的实际地址

• 查看对象 Class 的内存地址

  可以通过 Windows -> Console 进入命令行模式，执行

  mem 0x00000001299b4978 2

  mem 有两个参数，参数 1 是对象地址，参数 2 是查看 2 行（即 16 字节）
  结果中第二行 0x000000001b7d4028 即为 Class 的内存地址

• 查看类的 vtable

  • 方法1：Alt+R 进入 Inspector 工具，输入刚才的 Class 内存地址，看到如下界面
  • 方法2：或者 Tools -> Class Browser 输入 Dog 查找，可以得到相同的结果

  无论通过哪种方法，都可以找到 Dog Class 的 vtable 长度为 6，意思就是 Dog 类有 6 个虚方法（多态相关的，final，static 不会列入）

• 验证方法地址

  通过 Tools -> Class Browser 查看每个类的方法定义，比较可知

  Dog - public void eat() @0x000000001b7d3fa8
  Animal - public java.lang.String toString() @0x000000001b7d35e8;
  Object - protected void finalize() @0x000000001b3d1b10;
  Object - public boolean equals(java.lang.Object) @0x000000001b3d15e8;
  Object - public native int hashCode() @0x000000001b3d1540;
  Object - protected native java.lang.Object clone() @0x000000001b3d1678;
  

  对号入座，发现

  • eat() 方法是 Dog 类自己的
  • toString() 方法是继承 String 类的
  • finalize() ，equals()，hashCode()，clone() 都是继承 Object 类的

• 小结

  • 当执行 invokevirtual 指令时，
    1. 先通过栈帧中的对象引用找到对象
    2. 分析对象头，找到对象的实际 Class
    3. Class 结构中有 vtable，它在类加载的链接阶段就已经根据方法的重写规则生成好了
    4. 查表得到方法的具体地址
    5. 执行方法的字节码

4.2.6 异常处理

try-catch

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

public static void main(java.lang.String[]);
descriptor: ([Ljava/lang/String;)V
flags: ACC_PUBLIC, ACC_STATIC
Code:
stack=1, locals=3, args_size=1
0: iconst_0
1: istore_1
2: bipush 10
4: istore_1
5: goto 12
8: astore_2
9: bipush 20
11: istore_1
12: return
Exception table:
from to target type
2 5 8 Class java/lang/Exception
LineNumberTable: ...
LocalVariableTable:
Start Length Slot Name Signature
9 3 2 e Ljava/lang/Exception;
0 13 0 args [Ljava/lang/String;
2 11 1 i I
StackMapTable: ...
MethodParameters: ...
}

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

多个 single-catch 块的情况

public class Demo3_8 {
    public static void main(String[] args) {
        int i = 0;
        try {
            i = 10;
        } catch (ArithmeticException e) {
            i = 30;
        } catch (NullPointerException e) {
            i = 40;
        } catch (Exception e) {
            i = 50;
        }
    }
}

public static void main(java.lang.String[]);
descriptor: ([Ljava/lang/String;)V
flags: ACC_PUBLIC, ACC_STATIC
Code:
stack=1, locals=3, args_size=1
0: iconst_0
1: istore_1
2: bipush 10
4: istore_1
5: goto 26
8: astore_2
9: bipush 30
11: istore_1
12: goto 26
15: astore_2
16: bipush 40
18: istore_1
19: goto 26
22: astore_2
23: bipush 50
25: istore_1
26: return
Exception table:
from to target type
2 5 8 Class java/lang/ArithmeticException
2 5 15 Class java/lang/NullPointerException
2 5 22 Class java/lang/Exception
LineNumberTable: ...
LocalVariableTable:
Start Length Slot Name Signature
9 3 2 e Ljava/lang/ArithmeticException;
16 3 2 e Ljava/lang/NullPointerException;
23 3 2 e Ljava/lang/Exception;
0 27 0 args [Ljava/lang/String;
2 25 1 i I
StackMapTable: ...
MethodParameters: ...

因为异常出现时，只能进入 Exception table 中一个分支，所以局部变量表 slot 2 位置被共用

multi-catch 的情况

public class Demo3_9 {
    public static void main(String[] args) {
        try {
            Method test = Demo3_9.class.getMethod("test");
            test.invoke(null);
        } catch (NoSuchMethodException | IllegalAccessException |
                InvocationTargetException e) {
            e.printStackTrace();
        }
    }

    public static void test() {
        System.out.println("ok");
    }
}

public static void main(java.lang.String[]);
descriptor: ([Ljava/lang/String;)V
flags: ACC_PUBLIC, ACC_STATIC
Code:
stack=3, locals=2, args_size=1
0: ldc #2
2: ldc #3
4: iconst_0
5: anewarray #4
8: invokevirtual #5
11: astore_1
12: aload_1
13: aconst_null
14: iconst_0
15: anewarray #6
18: invokevirtual #7
21: pop
22: goto 30
25: astore_1
26: aload_1
27: invokevirtual #11 // e.printStackTrace:()V
30: return
Exception table:
from to target type
0 22 25 Class java/lang/NoSuchMethodException
0 22 25 Class java/lang/IllegalAccessException
0 22 25 Class java/lang/reflect/InvocationTargetException
LineNumberTable: ...
LocalVariableTable:
Start Length Slot Name Signature
12 10 1 test Ljava/lang/reflect/Method;
26 4 1 e Ljava/lang/ReflectiveOperationException;
0 31 0 args [Ljava/lang/String;
StackMapTable: ...
MethodParameters: ...

finally

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

public static void main(java.lang.String[]);
descriptor: ([Ljava/lang/String;)V
flags: ACC_PUBLIC, ACC_STATIC
Code:
stack=1, locals=4, args_size=1
0: iconst_0
1: istore_1 // 0 -> i
2: bipush 10 // try --------------------------------------
4: istore_1 // 10 -> i |
5: bipush 30 // finally |
7: istore_1 // 30 -> i |
8: goto 27 // return -----------------------------------
11: astore_2 // catch Exceptin -> e ----------------------
12: bipush 20 // |
14: istore_1 // 20 -> i |
15: bipush 30 // finally |
17: istore_1 // 30 -> i |
18: goto 27 // return -----------------------------------
21: astore_3 // catch any -> slot 3 ----------------------
22: bipush 30 // finally |
24: istore_1 // 30 -> i |
25: aload_3 // <- slot 3 |
26: athrow // throw ------------------------------------
27: return
Exception table:
from to target type
2 5 11 Class java/lang/Exception
2 5 21 any // 剩余的异常类型，比如 Error
11 15 21 any // 剩余的异常类型，比如 Error
LineNumberTable: ...
LocalVariableTable:
Start Length Slot Name Signature
12 3 2 e Ljava/lang/Exception;
0 28 0 args [Ljava/lang/String;
2 26 1 i I
StackMapTable: ...
MethodParameters: ...

可以看到 finally 中的代码被复制了 3 份，分别放入 try 流程，catch 流程以及 catch 剩余的异常类型流
程

4.2.7 练习 - finally 面试题

finally 出现了 return

先问问自己，下面的题目输出什么？

public class Demo3_11 {
    public static void main(String[] args) {
        int result = test();
        System.out.println(result);
    }

    public static int test() {
        try {
            return 10;
        } finally {
            return 20;
        }
    }
}

public static int test();
descriptor: ()I
flags: ACC_PUBLIC, ACC_STATIC
Code:
stack=1, locals=2, args_size=0
0: bipush 10 // <- 10 放入栈顶
2: istore_0 // 10 -> slot 0 (从栈顶移除了)
3: bipush 20 // <- 20 放入栈顶
5: ireturn // 返回栈顶 int(20)
6: astore_1 // catch any -> slot 1
7: bipush 20 // <- 20 放入栈顶
9: ireturn // 返回栈顶 int(20)
Exception table:
from to target type
0 3 6 any
LineNumberTable: ...
StackMapTable: ...

• 由于 finally 中的 ireturn 被插入了所有可能的流程，因此返回结果肯定以 finally 的为准
• 至于字节码中第 2 行，似乎没啥用，且留个伏笔，看下个例子
• 跟上例中的 finally 相比，发现没有 athrow 了，这告诉我们：如果在 finally 中出现了 return，会吞掉异常😱😱😱，可以试一下下面的代码

public class Demo3_12 {
    public static void main(String[] args) {
        int result = test();
        System.out.println(result);
    }

    public static int test() {
        try {
            int i = 1 / 0;
            return 10;
        } finally {
            return 20;
        }
    }
}

finally 对返回值影响

同样问问自己，下面的题目输出什么？

public class Demo3_13 {
    public static void main(String[] args) {
        int result = test();
        System.out.println(result);
    }

    public static int test() {
        int i = 10;
        try {
            return i;
        } finally {
            i = 20;
        }
    }
}

public static int test();
descriptor: ()I
flags: ACC_PUBLIC, ACC_STATIC
Code:
stack=1, locals=3, args_size=0
0: bipush 10 // <- 10 放入栈顶
2: istore_0 // 10 -> i
3: iload_0 // <- i(10)
4: istore_1 // 10 -> slot 1，暂存至 slot 1，目的是为了固定返回值
5: bipush 20 // <- 20 放入栈顶
7: istore_0 // 20 -> i
8: iload_1 // <- slot 1(10) 载入 slot 1 暂存的值
9: ireturn // 返回栈顶的 int(10)
10: astore_2
11: bipush 20
13: istore_0
14: aload_2
15: athrow
Exception table:
from to target type
3 5 10 any
LineNumberTable: ...
LocalVariableTable:
Start Length Slot Name Signature
3 13 0 i I
StackMapTable: ...

4.2.8 synchronized

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

public static void main(java.lang.String[]);
descriptor: ([Ljava/lang/String;)V
flags: ACC_PUBLIC, ACC_STATIC
Code:
stack=2, locals=4, args_size=1
0: new #2 // new Object
3: dup
4: invokespecial #1 // invokespecial <init>:()V
7: astore_1 // lock引用 -> lock
8: aload_1 // <- lock （synchronized开始）
9: dup
10: astore_2 // lock引用 -> slot 2
11: monitorenter // monitorenter(lock引用)
12: getstatic #3 // <- System.out
15: ldc #4 // <- "ok"
17: invokevirtual #5 // invokevirtual println:
(Ljava/lang/String;)V
20: aload_2 // <- slot 2(lock引用)
21: monitorexit // monitorexit(lock引用)
22: goto 30
25: astore_3 // any -> slot 3
26: aload_2 // <- slot 2(lock引用)
27: monitorexit // monitorexit(lock引用)
28: aload_3
29: athrow
30: return
Exception table:
from to target type
12 22 25 any
25 28 25 any
LineNumberTable: ...
LocalVariableTable:
Start Length Slot Name Signature
0 31 0 args [Ljava/lang/String;
8 23 1 lock Ljava/lang/Object;
StackMapTable: ...
MethodParameters: ...

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

4.3 类加载阶段

类加载有三个阶段：加载、链接、初始化

4.3.1 加载

• 将类的字节码载入方法区中，内部采用 C++ 的 instanceKlass 描述 java 类，它的重要 field 有：

  • _java_mirror 即 java 的类镜像，例如对 String 来说，就是 String.class，作用是把 klass 暴露给 java 使用
  • _super 即父类
  • _fields 即成员变量
  • _methods 即方法
  • _constants 即常量池
  • _class_loader 即类加载器
  • _vtable 虚方法表
  • _itable 接口方法表

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

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

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

  

4.3.2 链接

验证 ：验证类是否符合 JVM规范，安全性检查

用 UE 等支持二进制的编辑器修改 HelloWorld.class 的魔数，在控制台运行

E:\git\jvm\out\production\jvm>java cn.itcast.jvm.t5.HelloWorld
Error: A JNI error has occurred, please check your installation and try again
Exception in thread "main" java.lang.ClassFormatError: Incompatible magic value
3405691578 in class file cn/itcast/jvm/t5/HelloWorld
at java.lang.ClassLoader.defineClass1(Native Method)
at java.lang.ClassLoader.defineClass(ClassLoader.java:763)
at java.security.SecureClassLoader.defineClass(SecureClassLoader.java:142)
at java.net.URLClassLoader.defineClass(URLClassLoader.java:467)
at java.net.URLClassLoader.access$100(URLClassLoader.java:73)
at java.net.URLClassLoader$1.run(URLClassLoader.java:368)
at java.net.URLClassLoader$1.run(URLClassLoader.java:362)
at java.security.AccessController.doPrivileged(Native Method)
at java.net.URLClassLoader.findClass(URLClassLoader.java:361)
at java.lang.ClassLoader.loadClass(ClassLoader.java:424)
at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:331)
at java.lang.ClassLoader.loadClass(ClassLoader.java:357)
at sun.launcher.LauncherHelper.checkAndLoadMain(LauncherHelper.java:495)

准备

为 static 变量分配空间，设置默认值

• static 变量在 JDK 7 之前存储于 instanceKlass 末尾，从 JDK 7 开始，存储于 _java_mirror 末尾
• static 变量分配空间和赋值是两个步骤，分配空间在准备阶段完成，赋值在初始化阶段完成
• 如果 static 变量是 final 的基本类型，以及字符串常量，那么编译阶段值就确定了，赋值在准备阶段完成
• 如果 static 变量是 final 的，但属于引用类型，那么赋值也会在初始化阶段完成

解析

将常量池中的符号引用解析为直接引用

/**
 * 解析的含义
 */
public class Load1 {
    public static void main(String[] args) throws ClassNotFoundException, IOException {
        ClassLoader classloader = Load1.class.getClassLoader();
		// loadClass 方法不会导致类的解析和初始化
        Class<?> c = classloader.loadClass("cn.itcast.jvm.t3.load.C");
		// new C();
        System.in.read();
    }
}

class C {
    D d = new D();
}

class D {
}

4.3.3 初始化

<cinit>()V 方法

初始化即调用 <cinit>()V ，虚拟机会保证这个类的『构造方法』的线程安全

发生的时机

概括得说，类初始化是【懒惰的】

• main 方法所在的类，总会被首先初始化
• 首次访问这个类的静态变量或静态方法时
• 子类初始化，如果父类还没初始化，会引发
• 子类访问父类的静态变量，只会触发父类的初始化
• Class.forName
• new 会导致初始化

不会导致类初始化的情况

• 访问类的 static final 静态常量（基本类型和字符串）不会触发初始化
• 类对象.class 不会触发初始化
• 创建该类的数组不会触发初始化
• 类加载器的 loadClass 方法
• Class.forName 的参数 2 为 false 时

实验

class A {
  static int a = 0;
  static {
  	System.out.println("a init");
  }
}
class B extends A {
  final static double b = 5.0;
  static boolean c = false;
  static {
  	System.out.println("b init");
  }
}

验证（实验时请先全部注释，每次只执行其中一个）

public class Load3 {
    static {
        System.out.println("main init");
    }

    public static void main(String[] args) throws ClassNotFoundException {
		// 1. 静态常量（基本类型和字符串）不会触发初始化
        System.out.println(B.b);
		// 2. 类对象.class 不会触发初始化
        System.out.println(B.class);
		// 3. 创建该类的数组不会触发初始化
        System.out.println(new B[0]);
		// 4. 不会初始化类 B，但会加载 B、A
        ClassLoader cl = Thread.currentThread().getContextClassLoader();
        cl.loadClass("cn.itcast.jvm.t3.B");
		// 5. 不会初始化类 B，但会加载 B、A
        ClassLoader c2 = Thread.currentThread().getContextClassLoader();
        Class.forName("cn.itcast.jvm.t3.B", false, c2);
		// 1. 首次访问这个类的静态变量或静态方法时
        System.out.println(A.a);
		// 2. 子类初始化，如果父类还没初始化，会引发
        System.out.println(B.c);
		// 3. 子类访问父类静态变量，只触发父类初始化
        System.out.println(B.a);
		// 4. 会初始化类 B，并先初始化类 A
        Class.forName("cn.itcast.jvm.t3.B");
    }
}

4.3.4 练习

从字节码分析，使用 a，b，c 这三个常量是否会导致 E 初始化

public class Load4 {
    public static void main(String[] args) {
        System.out.println(E.a);
        System.out.println(E.b);
        System.out.println(E.c);
    }
}

class E {
    public static final int a = 10;
    public static final String b = "hello";
    public static final Integer c = 20;
}

典型应用 - 完成懒惰初始化单例模式

public final class Singleton {
    private Singleton() {
    }

    // 内部类中保存单例
    private static class LazyHolder {
        static final Singleton INSTANCE = new Singleton();
    }

    // 第一次调用 getInstance 方法，才会导致内部类加载和初始化其静态成员
    public static Singleton getInstance() {
        return LazyHolder.INSTANCE;
    }
}

以上的实现特点是：

• 懒惰实例化
• 初始化时的线程安全是有保障的

4.4 类加载器

以 JDK 8 为例：

名称	加载哪的类	说明
Bootstrap ClassLoader	JAVA_HOME/jre/lib	无法直接访问
Extension ClassLoader	JAVA_HOME/jre/lib/ext	上级为 Bootstrap，显示为 null
Application ClassLoader	classpath	上级为 Extension
自定义类加载器	自定义	上级为Application

4.4.1 启动类加载器

用 Bootstrap 类加载器加载类：

package cn.itcast.jvm.t3.load;
public class F {
  static {
  	System.out.println("bootstrap F init");
  }
}

执行

public class Load5_1 {
  public static void main(String[] args) throws ClassNotFoundException {
    Class<?> aClass = Class.forName("cn.itcast.jvm.t3.load.F");
    System.out.println(aClass.getClassLoader());
  }
}

输出

E:\git\jvm\out\production\jvm>java -Xbootclasspath/a:.
cn.itcast.jvm.t3.load.Load5
bootstrap F init
null

• -Xbootclasspath 表示设置 bootclasspath
• 其中 /a:. 表示将当前目录追加至 bootclasspath 之后
• 可以用这个办法替换核心类
  • java -Xbootclasspath:
  • java -Xbootclasspath/a:<追加路径>
  • java -Xbootclasspath/p:<追加路径>

4.4.2 扩展类加载器

public class G {
  static {
  	System.out.println("classpath G init");
  }
}

执行

public class Load5_2 {
  public static void main(String[] args) throws ClassNotFoundException {
    Class<?> aClass = Class.forName("cn.itcast.jvm.t3.load.G");
    System.out.println(aClass.getClassLoader());
  }
}

输出

classpath G init
sun.misc.Launcher$AppClassLoader@18b4aac2

写一个同名的类

public class G {
  static {
    System.out.println("ext G init");
  }
}

打个 jar 包

E:\git\jvm\out\production\jvm>jar -cvf my.jar cn/itcast/jvm/t3/load/G.class
已添加清单
正在添加: cn/itcast/jvm/t3/load/G.class(输入 = 481) (输出 = 322)(压缩了 33%)

将 jar 包拷贝到 JAVA_HOME/jre/lib/ext

重新执行 Load5_2，输出

ext G init
sun.misc.Launcher$ExtClassLoader@29453f44

4.4.3 双亲委派模式

所谓的双亲委派，就是指调用类加载器的 loadClass 方法时，查找类的规则（这里的双亲，翻译为上级似乎更为合适，因为它们并没有继承关系）

protected Class<?> loadClass(String name, boolean resolve)
        throws ClassNotFoundException {
    synchronized (getClassLoadingLock(name)) {
        // 1. 检查该类是否已经加载
        Class<?> c = findLoadedClass(name);
        if (c == null) {
            long t0 = System.nanoTime();
            try {
                if (parent != null) {
                    // 2. 有上级的话，委派上级 loadClass
                    c = parent.loadClass(name, false);
                } else {
                    // 3. 如果没有上级了（ExtClassLoader），则委派
                    BootstrapClassLoader
                            c = findBootstrapClassOrNull(name);
                }
            } catch (ClassNotFoundException e) {
            }
            if (c == null) {
                long t1 = System.nanoTime();
                // 4. 每一层找不到，调用 findClass 方法（每个类加载器自己扩展）来加载
                c = findClass(name);
                // 5. 记录耗时
                sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
                sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
                sun.misc.PerfCounter.getFindClasses().increment();
            }
        }
        if (resolve) {
            resolveClass(c);
        }
        return c;
    }
}

例如：

public class Load5_3 {
    public static void main(String[] args) throws ClassNotFoundException {
        Class<?> aClass = Load5_3.class.getClassLoader()
                .loadClass("cn.itcast.jvm.t3.load.H");
        System.out.println(aClass.getClassLoader());
    }
}

执行流程为：

1. sun.misc.Launcher$AppClassLoader //1 处， 开始查看已加载的类，结果没有
2. sun.misc.Launcher$AppClassLoader // 2 处，委派上级
   sun.misc.Launcher$ExtClassLoader.loadClass()
3. sun.misc.Launcher$ExtClassLoader // 1 处，查看已加载的类，结果没有
4. sun.misc.Launcher$ExtClassLoader // 3 处，没有上级了，则委派 BootstrapClassLoader
   查找
5. BootstrapClassLoader 是在 JAVA_HOME/jre/lib 下找 H 这个类，显然没有
6. sun.misc.Launcher$ExtClassLoader // 4 处，调用自己的 findClass 方法，是在
   JAVA_HOME/jre/lib/ext 下找 H 这个类，显然没有，回到 sun.misc.Launcher$AppClassLoader
   的 // 2 处
7. 继续执行到 sun.misc.Launcher$AppClassLoader // 4 处，调用它自己的 findClass 方法，在
   classpath 下查找，找到了

4.4.4 线程上下文类加载器

我们在使用 JDBC 时，都需要加载 Driver 驱动，不知道你注意到没有，不写

Class.forName("com.mysql.jdbc.Driver")

也是可以让 com.mysql.jdbc.Driver 正确加载的，你知道是怎么做的吗？让我们追踪一下源码：

public class DriverManager {
  // 注册驱动的集合
  private final static CopyOnWriteArrayList<DriverInfo> registeredDrivers= new CopyOnWriteArrayList<>();
  // 初始化驱动
  static {
  	loadInitialDrivers();
  	println("JDBC DriverManager initialized");
  }
  ...
}

先不看别的，看看 DriverManager 的类加载器：

System.out.println(DriverManager.class.getClassLoader());

打印 null，表示它的类加载器是 Bootstrap ClassLoader，会到 JAVA_HOME/jre/lib 下搜索类，但JAVA_HOME/jre/lib 下显然没有 mysql-connector-java-5.1.47.jar 包，这样问题来了，在DriverManager 的静态代码块中，怎么能正确加载 com.mysql.jdbc.Driver 呢？

继续看 loadInitialDrivers() 方法：

private static void loadInitialDrivers() {
    String drivers;
    try {
        drivers = AccessController.doPrivileged(new PrivilegedAction<String>() {
            public String run() {
                return System.getProperty("jdbc.drivers");
            }
        });
    } catch (Exception ex) {
        drivers = null;
    }
    // If the driver is packaged as a Service Provider, load it.
    // Get all the drivers through the classloader
    // exposed as a java.sql.Driver.class service.
    // ServiceLoader.load() replaces the sun.misc.Providers()
  
	// 1）使用 ServiceLoader 机制加载驱动，即 SPI
    AccessController.doPrivileged(new PrivilegedAction<Void>() {
        public Void run() {

            ServiceLoader<Driver> loadedDrivers = ServiceLoader.load(Driver.class);
            Iterator<Driver> driversIterator = loadedDrivers.iterator();

            /* Load these drivers, so that they can be instantiated.
             * It may be the case that the driver class may not be there
             * i.e. there may be a packaged driver with the service class
             * as implementation of java.sql.Driver but the actual class
             * may be missing. In that case a java.util.ServiceConfigurationError
             * will be thrown at runtime by the VM trying to locate
             * and load the service.
             *
             * Adding a try catch block to catch those runtime errors
             * if driver not available in classpath but it's
             * packaged as service and that service is there in classpath.
             */
            try{
                while(driversIterator.hasNext()) {
                    driversIterator.next();
                }
            } catch(Throwable t) {
            // Do nothing
            }
            return null;
        }
    });

    println("DriverManager.initialize: jdbc.drivers = " + drivers);

  	// 2）使用 jdbc.drivers 定义的驱动名加载驱动
    if (drivers == null || drivers.equals("")) {
        return;
    }
    String[] driversList = drivers.split(":");
    println("number of Drivers:" + driversList.length);
    for (String aDriver : driversList) {
        try {
            println("DriverManager.Initialize: loading " + aDriver);
            Class.forName(aDriver, true,
                    ClassLoader.getSystemClassLoader());
        } catch (Exception ex) {
            println("DriverManager.Initialize: load failed: " + ex);
        }
    }
}

先看 2）发现它最后是使用 Class.forName 完成类的加载和初始化，关联的是应用程序类加载器，因此可以顺利完成类加载

再看 1）它就是大名鼎鼎的 Service Provider Interface （SPI）

约定如下，在 jar 包的 META-INF/services 包下，以接口全限定名名为文件，文件内容是实现类名称

这样就可以使用

ServiceLoader<接口类型> allImpls = ServiceLoader.load(接口类型.class);
Iterator<接口类型> iter = allImpls.iterator();
while(iter.hasNext()) {
	iter.next();
}

来得到实现类，体现的是【面向接口编程+解耦】的思想，在下面一些框架中都运用了此思想：

• JDBC
• Servlet 初始化器
• Spring 容器
• Dubbo（对 SPI 进行了扩展）

接着看 ServiceLoader.load 方法：

public static <S> ServiceLoader<S> load(Class<S> service) {
  // 获取线程上下文类加载器
  ClassLoader cl = Thread.currentThread().getContextClassLoader();
  return ServiceLoader.load(service, cl);
}

线程上下文类加载器是当前线程使用的类加载器，默认就是应用程序类加载器，它内部又是由Class.forName 调用了线程上下文类加载器完成类加载，具体代码在 ServiceLoader 的内部类LazyIterator 中：

private S nextService() {
	if (!hasNextService())
		throw new NoSuchElementException();
	String cn = nextName;
	nextName = null;
	Class<?> c = null;
	try {
		c = Class.forName(cn, false, loader);
	} catch (ClassNotFoundException x) {
		fail(service,
         "Provider " + cn + " not found");
	}
    if (!service.isAssignableFrom(c)) {
    	fail(service,
    	"Provider " + cn + " not a subtype");
    }
    try {
    	S p = service.cast(c.newInstance());
    	providers.put(cn, p);
    	return p;
    } catch (Throwable x) {
    	fail(service,
    	"Provider " + cn + " could not be instantiated",x);
    }
    throw new Error(); // This cannot happen
}

4.4.5 自定义类加载器

问问自己，什么时候需要自定义类加载器

• 想加载非 classpath 随意路径中的类文件
• 都是通过接口来使用实现，希望解耦时，常用在框架设计
• 这些类希望予以隔离，不同应用的同名类都可以加载，不冲突，常见于 tomcat 容器

步骤：

1. 继承 ClassLoader 父类
2. 要遵从双亲委派机制，重写 findClass 方法
   注意不是重写 loadClass 方法，否则不会走双亲委派机制
3. 读取类文件的字节码
4. 调用父类的 defineClass 方法来加载类
5. 使用者调用该类加载器的 loadClass 方法

5. 内存模型

很多人将【java 内存结构】与【java 内存模型】傻傻分不清，【java 内存模型】是 Java Memory Model（JMM）的意思。

关于它的权威解释，请参考 https://download.oracle.com/otn-pub/jcp/memory_model-1.0-pfdspec-oth-JSpec/memory_model-1_0-pfd-spec.pdf?AuthParam=1562811549_4d4994cbd5b59d964cd2907ea22ca08b

简单的说，JMM 定义了一套在多线程读写共享数据时（成员变量、数组）时，对数据的可见性、有序性、和原子性的规则和保障

5.1 原子性

两个线程对初始值为 0 的静态变量一个做自增，一个做自减，各做 5000 次，结果是 0 吗？

以上的结果可能是正数、负数、零。因为 Java 中对静态变量的自增，自减并不是原子操作。

例如对于 i++ 而言（i 为静态变量），实际会产生如下的 JVM 字节码指令：

getstatic i // 获取静态变量i的值
iconst_1 // 准备常量1
iadd // 加法
putstatic i // 将修改后的值存入静态变量i

而对应 i-- 也是类似：

getstatic i // 获取静态变量i的值
iconst_1 // 准备常量1
isub // 减法
putstatic i // 将修改后的值存入静态变量i

而 Java 的内存模型分为主内存和工作内存

完成静态变量的自增、自减需要在主存和线程内存中进行数据交换：

如果是单线程以上 8 行代码是顺序执行（不会交错）没有问题：

// 假设i的初始值为0
getstatic 	i 	// 线程1-获取静态变量i的值 线程内i=0
iconst_		1 	// 线程1-准备常量1
iadd 			// 线程1-自增 线程内i=1
putstatic 	i 	// 线程1-将修改后的值存入静态变量i 静态变量i=1
getstatic 	i 	// 线程1-获取静态变量i的值 线程内i=1
iconst_		1 	// 线程1-准备常量1
isub 			// 线程1-自减 线程内i=0
putstatic 	i 	// 线程1-将修改后的值存入静态变量i 静态变量i=0

但多线程下这 8 行代码可能交错运行

解决方式：

synchronized （同步关键字）

语法：

synchronized( 对象 ) {
	要作为原子操作代码
}

用 synchronized 解决并发问题：

static int i = 0;
static Object obj = new Object();

public static void main(String[] args) throws InterruptedException {
    Thread t1 = new Thread(() -> {
        for (int j = 0; j < 5000; j++) {
            synchronized (obj) {
                i++;
            }
        }
    });
    Thread t2 = new Thread(() -> {
        for (int j = 0; j < 5000; j++) {
            synchronized (obj) {
                i--;
            }
        }
    });
    t1.start();
    t2.start();
    t1.join();
    t2.join();
    System.out.println(i);
}

理解：可以把 obj 想象成一个房间，线程 t1，t2 想象成两个人。

当线程 t1 执行到 synchronized(obj) 时就好比 t1 进入了这个房间，并反手锁住了门，在门内执行count++ 代码。

这时候如果 t2 也运行到了 synchronized(obj) 时，它发现门被锁住了，只能在门外等待。

当 t1 执行完 synchronized{} 块内的代码，这时候才会解开门上的锁，从 obj 房间出来。t2 线程这时才可以进入 obj 房间，反锁住门，执行它的 count-- 代码。

上例中 t1 和 t2 线程必须用 synchronized 锁住同一个 obj 对象，如果 t1 锁住的是 m1 对
象，t2 锁住的是 m2 对象，就好比两个人分别进入了两个不同的房间，没法起到同步的效果。

5.2 可见性

先来看一个现象，main 线程对 run 变量的修改对于 t 线程不可见，导致了 t 线程无法停止：

    static boolean run = true;

    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            while (run) {
// ....
            }
        });
        t.start();
        Thread.sleep(1000);
        run = false; // 线程t不会如预想的停下来
    }

为什么呢？分析一下：

1. 初始状态， t 线程刚开始从主内存读取了 run 的值到工作内存。

   

2. 因为 t 线程要频繁从主内存中读取 run 的值，JIT 编译器会将 run 的值缓存至自己工作内存中的高
   速缓存中，减少对主存中 run 的访问，提高效率

   

3. 1 秒之后，main 线程修改了 run 的值，并同步至主存，而 t 是从自己工作内存中的高速缓存中读
   取这个变量的值，结果永远是旧值

   

解决方法：

volatile 易变关键字

它可以用来修饰成员变量和静态成员变量，他可以避免线程从自己的工作缓存中查找变量的值，必须到主存中获取它的值，线程操作 volatile 变量都是直接操作主存

前面例子volatile体现的实际就是可见性，它保证在多个线程之间，一个线程对 volatile 变量的修改对另一个线程可见， 不能保证互斥和原子性（synchronized保证可见性、原子性、有序性），仅用在一个写线程，多个读线程的情况。上例从字节码理解是这样的：

getstatic run // 线程 t 获取 run true
getstatic run // 线程 t 获取 run true
getstatic run // 线程 t 获取 run true
getstatic run // 线程 t 获取 run true
putstatic run // 线程 main 修改 run 为 false， 仅此一次
getstatic run // 线程 t 获取 run false

比较一下之前我们将线程安全时举的例子：两个线程一个 i++ 一个 i-- ，只能保证看到最新值，不能解决指令交错

// 假设i的初始值为0
getstatic i // 线程1-获取静态变量i的值 线程内i=0
getstatic i // 线程2-获取静态变量i的值 线程内i=0
iconst_1 // 线程1-准备常量1
iadd // 线程1-自增 线程内i=1
putstatic i // 线程1-将修改后的值存入静态变量i 静态变量i=1
iconst_1 // 线程2-准备常量1
isub // 线程2-自减 线程内i=-1
putstatic i // 线程2-将修改后的值存入静态变量i 静态变量i=-1

synchronized 语句块既可以保证代码块的原子性，也同时保证代码块内变量的可见性。但缺点是synchronized是属于重量级操作，性能相对更低

如果在前面示例的死循环中加入 System.out.println() 会发现即使不加 volatile 修饰符，线程 t 也能正确看到对 run 变量的修改了，想一想为什么？

因为println底层有synchronized关键字

5.3 有序性

int num = 0;
boolean ready = false;
// 线程1 执行此方法
public void actor1(I_Result r) {
    if(ready) {
      	r.r1 = num + num;
    } else {
      	r.r1 = 1;
    }
}
// 线程2 执行此方法
public void actor2(I_Result r) {
	num = 2;
	ready = true;
}

I_Result 是一个对象，有一个属性 r1 用来保存结果，问，可能的结果有几种？
可以这么分析
情况1：线程1 先执行，这时 ready = false，所以进入 else 分支结果为 1
情况2：线程2 先执行 num = 2，但没来得及执行 ready = true，线程1 执行，还是进入 else 分支，结果为1
情况3：线程2 执行到 ready = true，线程1 执行，这回进入 if 分支，结果为 4（因为 num 已经执行过了）

但其实结果还有可能是 0

这种情况下是：线程2 执行 ready = true，切换到线程1，进入 if 分支，相加为 0，再切回线程2 执行 num = 2

这种现象叫做指令重排，是 JIT 编译器在运行时的一些优化，这个现象需要通过大量测试才能复现：借助 java 并发压测工具 jcstress https://wiki.openjdk.java.net/display/CodeTools/jcstress

mvn archetype:generate -DinteractiveMode=false -DarchetypeGroupId=org.openjdk.jcstress -DarchetypeArtifactId=jcstress-java-testarchetype-DgroupId=org.sample -DartifactId=test -Dversion=1.0

创建 maven 项目，提供如下测试类

@JCStressTest
@Outcome(id = {"1", "4"}, expect = Expect.ACCEPTABLE, desc = "ok")
@Outcome(id = "0", expect = Expect.ACCEPTABLE_INTERESTING, desc = "!!!!")
@State
public class ConcurrencyTest {
    int num = 0;
    boolean ready = false;
    @Actor
    public void actor1(I_Result r) {
        if(ready) {
        	r.r1 = num + num;
        } else {
        	r.r1 = 1;
        }
    }
    @Actor
    public void actor2(I_Result r) {
        num = 2;
        ready = true;
    }
}

执行

mvn clean install

java -jar target/jcstress.jar

会输出我们感兴趣的结果，摘录其中一次结果：

*** INTERESTING tests
Some interesting behaviors observed. This is for the plain curiosity.
2 matching test results.
[OK] test.ConcurrencyTest
(JVM args: [-XX:-TieredCompilation])
Observed state Occurrences Expectation Interpretation
0 1,729 ACCEPTABLE_INTERESTING !!!!
1 42,617,915 ACCEPTABLE ok
4 5,146,627 ACCEPTABLE ok
[OK] test.ConcurrencyTest
(JVM args: [])
Observed state Occurrences Expectation Interpretation
0 1,652 ACCEPTABLE_INTERESTING !!!!
1 46,460,657 ACCEPTABLE ok
4 4,571,072 ACCEPTABLE ok

可以看到，出现结果为 0 的情况有 638 次，虽然次数相对很少，但毕竟是出现了。

解决方法:

volatile 修饰的变量，可以禁用指令重排

@JCStressTest
@Outcome(id = {"1", "4"}, expect = Expect.ACCEPTABLE, desc = "ok")
@Outcome(id = "0", expect = Expect.ACCEPTABLE_INTERESTING, desc = "!!!!")
@State
public class ConcurrencyTest {
    int num = 0;
    volatile boolean ready = false;
    @Actor
    public void actor1(I_Result r) {
        if(ready) {
        	r.r1 = num + num;
        } else {
        	r.r1 = 1;
        }
    }
    @Actor
    public void actor2(I_Result r) {
        num = 2;
        ready = true;
    }
}

结果为：

*** INTERESTING tests
Some interesting behaviors observed. This is for the plain curiosity.
0 matching test results.

有序性理解

JVM 会在不影响正确性的前提下，可以调整语句的执行顺序，思考下面一段代码

static int i;
static int j;
// 在某个线程内执行如下赋值操作
i = ...; // 较为耗时的操作
j = ...;

可以看到，至于是先执行 i 还是 先执行 j ，对最终的结果不会产生影响。所以，上面代码真正执行
时，既可以是

i = ...; // 较为耗时的操作
j = ...;

也可以是

j = ...;
i = ...; // 较为耗时的操作

这种特性称之为『指令重排』，多线程下『指令重排』会影响正确性，例如著名的 double-checkedlocking 模式实现单例

public final class Singleton {
    private Singleton() {
    }

    private static Singleton INSTANCE = null;

    public static Singleton getInstance() {
        // 实例没创建，才会进入内部的 synchronized代码块
        if (INSTANCE == null) {
            synchronized (Singleton.class) {
                // 也许有其它线程已经创建实例，所以再判断一次
                if (INSTANCE == null) {
                    INSTANCE = new Singleton();
                }
            }
        }
        return INSTANCE;
    }
}

以上的实现特点是：

• 懒惰实例化
• 首次使用 getInstance() 才使用 synchronized 加锁，后续使用时无需加锁

但在多线程环境下，上面的代码是有问题的， INSTANCE = new Singleton() 对应的字节码为：

0: new #2 // class cn/itcast/jvm/t4/Singleton
3: dup
4: invokespecial #3 // Method "<init>":()V
7: putstatic #4 // Field
INSTANCE:Lcn/itcast/jvm/t4/Singleton;

其中 4 7 两步的顺序不是固定的，也许 jvm 会优化为：先将引用地址赋值给 INSTANCE 变量后，再执行
构造方法，如果两个线程 t1，t2 按如下时间序列执行：

时间1 t1 线程执行到 INSTANCE = new Singleton();
时间2 t1 线程分配空间，为Singleton对象生成了引用地址（0 处）
时间3 t1 线程将引用地址赋值给 INSTANCE，这时 INSTANCE != null（7 处）
时间4 t2 线程进入getInstance() 方法，发现 INSTANCE != null（synchronized块外），直接
返回 INSTANCE
时间5 t1 线程执行Singleton的构造方法（4 处）

这时 t1 还未完全将构造方法执行完毕，如果在构造方法中要执行很多初始化操作，那么 t2 拿到的是将
是一个未初始化完毕的单例

对 INSTANCE 使用 volatile 修饰即可，可以禁用指令重排，但要注意在 JDK 5 以上的版本的 volatile 才
会真正有效

5.4 CAS与原子类

5.4.1 CAS

CAS 即 Compare and Swap ，它体现的是一种乐观锁的思想，也被称为无锁并发。比如多个线程要对一个共享的整型变量执行 +1 操作：

// 需要不断尝试
while (true) {
    int 旧值 = 共享变量; // 比如拿到了当前值 0
    int 结果 = 旧值 + 1; // 在旧值 0 的基础上增加 1 ，正确结果是 1
    /*
    这时候如果别的线程把共享变量改成了 5，本线程的正确结果 1 就作废了，这时候
    compareAndSwap 返回 false，重新尝试，直到：
    compareAndSwap 返回 true，表示我本线程做修改的同时，别的线程没有干扰
    */
    if (compareAndSwap(旧值, 结果)) {
    	// 成功，退出循环
    }
}

获取共享变量时，为了保证该变量的可见性，需要使用 volatile 修饰。结合 CAS 和 volatile 可以实现无锁并发，适用于竞争不激烈、多核 CPU 的场景下。

• 因为没有使用 synchronized，所以线程不会陷入阻塞，这是效率提升的因素之一
• 但如果竞争激烈，可以想到重试必然频繁发生，反而效率会受影响

CAS 底层依赖于一个 Unsafe 类来直接调用操作系统底层的 CAS 指令，下面是直接使用 Unsafe 对象进行线程安全保护的一个例子

import sun.misc.Unsafe;

import java.lang.reflect.Field;

public class TestCAS {
    public static void main(String[] args) throws InterruptedException {
        DataContainer dc = new DataContainer();
        int count = 5;
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < count; i++) {
                dc.increase();
            }
        });
        t1.start();
        t1.join();
        System.out.println(dc.getData());
    }
}

class DataContainer {
    private volatile int data;
    static final Unsafe unsafe;
    static final long DATA_OFFSET;

    static {
        try {
            // Unsafe 对象不能直接调用，只能通过反射获得
            Field theUnsafe = Unsafe.class.getDeclaredField("theUnsafe");
            theUnsafe.setAccessible(true);
            unsafe = (Unsafe) theUnsafe.get(null);
        } catch (NoSuchFieldException | IllegalAccessException e) {
            throw new Error(e);
        }
        try {
            // data 属性在 DataContainer 对象中的偏移量，用于 Unsafe 直接访问该属性
            DATA_OFFSET =
                    unsafe.objectFieldOffset(DataContainer.class.getDeclaredField("data"));
        } catch (NoSuchFieldException e) {
            throw new Error(e);
        }
    }

    public void increase() {
        int oldValue;
        while (true) {
            // 获取共享变量旧值，可以在这一行加入断点，修改 data 调试来加深理解
            oldValue = data;
            // cas 尝试修改 data 为 旧值 + 1，如果期间旧值被别的线程改了，返回 false
            if (unsafe.compareAndSwapInt(this, DATA_OFFSET, oldValue, oldValue +
                    1)) {
                return;
            }
        }
    }

    public void decrease() {
        int oldValue;
        while (true) {
            oldValue = data;
            if (unsafe.compareAndSwapInt(this, DATA_OFFSET, oldValue, oldValue -
                    1)) {
                return;
            }
        }
    }

    public int getData() {
        return data;
    }
}

5.4.2 原子操作类

juc（java.util.concurrent）中提供了原子操作类，可以提供线程安全的操作，例如：AtomicInteger、AtomicBoolean等，它们底层就是采用 CAS 技术 + volatile 来实现的。

可以使用 AtomicInteger 改写之前的例子：

private static AtomicInteger i=new AtomicInteger(0);

public static void main(String[]args)throws InterruptedException{
    Thread t1=new Thread(()->{
        for(int j=0;j< 5000;j++){
            i.getAndIncrement(); // 获取并且自增 i++
            // i.incrementAndGet(); // 自增并且获取 ++i
        }
    });
    Thread t2=new Thread(()->{
        for(int j=0;j< 5000;j++){
          	i.getAndDecrement(); // 获取并且自减 i--
        }
    });
    t1.start();
    t2.start();
    t1.join();
    t2.join();
    System.out.println(i);
}

5.5 synchronized优化

Java HotSpot 虚拟机中，每个对象都有对象头（包括 class 指针和 Mark Word）。Mark Word 平时存储这个对象的 哈希码、分代年龄，当加锁时，这些信息就根据情况被替换为 标记位、线程锁记录指针、重量级锁指针、线程ID 等内容

5.5.1 轻量级锁

如果一个对象虽然有多线程访问，但多线程访问的时间是错开的（也就是没有竞争），那么可以使用轻量级锁来优化。这就好比：

学生（线程 A）用课本占座，上了半节课，出门了（CPU时间到），回来一看，发现课本没变，说明没有竞争，继续上他的课。

如果这期间有其它学生（线程 B）来了，会告知（线程A）有并发访问，线程 A 随即升级为重量级锁，进入重量级锁的流程。

而重量级锁就不是那么用课本占座那么简单了，可以想象线程 A 走之前，把座位用一个铁栅栏围起来

假设有两个方法同步块，利用同一个对象加锁

static Object obj = new Object();
public static void method1() {
    synchronized( obj ) {
        // 同步块 A
        method2();
    }
}
public static void method2() {
    synchronized( obj ) {
    	// 同步块 B
    }
}

每个线程都的栈帧都会包含一个锁记录的结构，内部可以存储锁定对象的 Mark Word

5.5.2 锁膨胀

如果在尝试加轻量级锁的过程中，CAS 操作无法成功，这时一种情况就是有其它线程为此对象加上了轻量级锁（有竞争），这时需要进行锁膨胀，将轻量级锁变为重量级锁。

static Object obj = new Object();
public static void method1() {
  	synchronized( obj ) {
 		 // 同步块
	}
}

5.5.3 重量锁

重量级锁竞争的时候，还可以使用自旋来进行优化，如果当前线程自旋成功（即这时候持锁线程已经退出了同步块，释放了锁），这时当前线程就可以避免阻塞。
在 Java 6 之后自旋锁是自适应的，比如对象刚刚的一次自旋操作成功过，那么认为这次自旋成功的可能性会高，就多自旋几次；反之，就少自旋甚至不自旋，总之，比较智能。

• 自旋会占用 CPU 时间，单核 CPU 自旋就是浪费，多核 CPU 自旋才能发挥优势。
• 好比等红灯时汽车是不是熄火，不熄火相当于自旋（等待时间短了划算），熄火了相当于阻塞（等待时间长了划算）
• Java 7 之后不能控制是否开启自旋功能

5.5.4 偏向锁

轻量级锁在没有竞争时（就自己这个线程），每次重入仍然需要执行 CAS 操作。Java 6 中引入了偏向锁来做进一步优化：只有第一次使用 CAS 将线程 ID 设置到对象的 Mark Word 头，之后发现这个线程 ID是自己的就表示没有竞争，不用重新 CAS.

• 撤销偏向需要将持锁线程升级为轻量级锁，这个过程中所有线程需要暂停（STW）
• 访问对象的 hashCode 也会撤销偏向锁
• 如果对象虽然被多个线程访问，但没有竞争，这时偏向了线程 T1 的对象仍有机会重新偏向 T2，
• 重偏向会重置对象的 Thread ID
• 撤销偏向和重偏向都是批量进行的，以类为单位
• 如果撤销偏向到达某个阈值，整个类的所有对象都会变为不可偏向的
• 可以主动使用 -XX:-UseBiasedLocking 禁用偏向锁

可以参考这篇论文：https://www.oracle.com/technetwork/java/biasedlocking-oopsla2006-wp-149958.pdf

假设有两个方法同步块，利用同一个对象加锁

static Object obj = new Object();
public static void method1() {
synchronized( obj ) {
    // 同步块 A
    method2();
  }
}
public static void method2() {
  synchronized( obj ) {
  	// 同步块 B
  }
}

5.5.5 其他优化

1. 减少上锁时间

同步代码块中尽量短

2. 减少锁的粒度

将一个锁拆分为多个锁提高并发度，例如：

• ConcurrentHashMap
• LongAdder 分为 base 和 cells 两部分。没有并发争用的时候或者是 cells 数组正在初始化的时候，会使用 CAS 来累加值到 base，有并发争用，会初始化 cells 数组，数组有多少个 cell，就允许有多少线程并行修改，最后将数组中每个 cell 累加，再加上 base 就是最终的值
• LinkedBlockingQueue 入队和出队使用不同的锁，相对于LinkedBlockingArray只有一个锁效率要高

3. 锁粗化

   多次循环进入同步块不如同步块内多次循环

   另外 JVM 可能会做如下优化，把多次 append 的加锁操作粗化为一次（因为都是对同一个对象加锁，没必要重入多次）

4. 锁消除

JVM 会进行代码的逃逸分析，例如某个加锁对象是方法内局部变量，不会被其它线程所访问到，这时候就会被即时编译器忽略掉所有同步操作。
5. 读写分离

CopyOnWriteArrayList
ConyOnWriteSet