面试5.1-CMS类文件结构heapdump文件编译期/运行期优化分层编译策略

接口

package test;
public interface HelloSpi {
    public String getName();
}

实现类

package test;
public class HelloSpi0 implements HelloSpi {
    @Override
    public String getName() {
        return "HelloSpiImpl1";
    }
}
public class HelloSpiImpl2 implements HelloSpi {
    @Override
    public String getName() {
        return "HelloSpiImpl2";
    }
}

resource目录下内容

test.HelloSpi0
test.HelloSpiImpl2

测试类

package test;
import java.util.ServiceLoader;
public class SPITest {
    public static void main(String[] args) {
        ServiceLoader helloSpis = ServiceLoader.load(HelloSpi.class);
        for(HelloSpi hello:helloSpis){
            System.out.println(hello.getName());
        }
    }
}

重点
最核心的部分是：通过ServiceLoader这个类去加载接口的具体实现类。
而不是之前的通过创建具体实现类的对象，而去调用实现类的方法。
SPI可以让父类委托子类去加载不在自己目录下的类，这样打破了双亲委派机制。（不理解xhj）
2022/5/20 ：ServiceLoader.load 为给定的服务类型创建了一个新的服务加载器，是ServiceLoader类的。

ServiceLoader

• 概念：
  Tomcat服务器是一个免费的开放源代码的Web应用的轻量级服务器。
• 打破双亲委派的介绍：
  初学部署项目，会把war包放在tomcat的webapp下，意味着一个tomcat可以运行多个web应用程序
  假设两个web应用程序，都有相同的类User，且类全限定名一样，为com.test.User，但具体实现不一样；
  Tomcat可以保证两个类不冲突，通过给每个Web应用创建一个类加载器实例（WebAppClassLoader），该加载器重写了LoadClass方法，优先加载当前应用程序目录下的类，如找不到才会一层层往上查找；
  这就做到Web应用层级的隔离；
• 总结：

• 概述：
  JNDI服务 = java Naming and Directory Interface，java命名和目录接口，是SUN公司提供的一种标准的Java命名系统接口。为开发人员提供了查找和访问各种命名和目录服务的通道、统一的接口，类似JDBC都是构建在抽象层上。
• 打破双亲委派机制的介绍：
  JNDI是java的标准服务，它的代码由启动类加载器去加载。但是JNDI需要回调独立厂商实现的代码，而类加载器无法识别这些回调代码（API）；
  为了解决该问题，引入一个线程上下文类加载器，可以通过java.lang.Thread类的setContextClassLoader()方法设置；
  如果创建线程的时候没有设置，线程上下文类加载器将会从父线程中继承；
  如果应用程序在全局范围内都没有设置过，那么这个类加载器默认就是AppClassLoader。
  有两个线程上下文类加载器，可以去加载所需要的SPI代码，即父类加载器请求子类加载器去完成类加载动作，也就打破了双亲委派模型的层次结构来逆向使用类加载器的方式。

• 概念：
  Spring框架是一个开放源代码的J2EE应用程序框架。
  J2EE = java 2 Platform Enterprise Edition ，本质是一个分布式的服务器应用程序设计环境（java环境）。提供了基于组件的方式来设计、开发、组装和部署企业应用。
• 打破双亲委派机制介绍：
  Spring对用户程序进行组织和管理，应用程序一般存放在WEB-INF目录下，由WebAppClassLoader类加载器加载；
  而Spring由Common类加载器或Shared类加载器加载；Spring如何加载WEB-INF下的应用程序呢？
  使用线程上下文类加载器。
  Spring加载类所用的classLoader都是通过Thread.currenThread().getContextClassLoader()获取。
  通过setContextClassLoader(AppClassLoader) 来加载应用程序。每个类创建时都会默认创建一个AppClassLoader类加载器。

前端编译器在编译期的优化过程占重要地位，java中的及时编译器在运行期间的优化过程占重要地位。

• java语言的编译期就是一段不确定的操作过程：
  它可能指前端编译器把java文件转变成class字节码文件的过程，也可以指虚拟机后端运行期间编译器（JIT，Just In Time Compiler）把字节码编程机器码的过程。
• 它可以分为三类编译过程：
  前端编译：把.java文件转变为.class文件
  后端编译：把字节码（.class文件）转变为机器码
  静态提前编译：直接把.java文件编译成本地机器代码

图示：

解析分为词法分析、语法分析两个步骤

• 词法分析：
  将源代码的字符流转变为标记集合（token）；
  单个字符是程序编写过程的最小元素，标记则是编译过程的最小元素；
• 语法分析：
  根据token序列（标记集合）构造抽象语法树的过程。
  抽象语法树（AST）：是一种用来描述程序代码语法结构的树形表示方式，语法树中的每个节点都代表着程序代码中的语法结构。
  填充符号表
  enterTree()方法实现。
  符号表：是由一组符号地址和符号信息构成的表格，符号表中登记的信息在编译的不同阶段都要用到。
  语义分析中，符号表所登记的内容将用于语义检查和产生中间代码；
  在目标代码产生阶段，当对符号进行地址分配时，符号表是地址分配的依据。

enterTree()：
实现抽象语法树的填充，主要为节点填充symbol和type，生成env；主要针对根节点、class节点、class的成员节点。
填充过程两个阶段：
①classEnter（tree，null）：遍历根节点与class节点，填充package和类自身，以及类的参数类型使用的范围；
②.1 clazz.complete() 进一步完成的类的env进入到umcompleted中；
②.2 finish（toFlnish），生成属性的varSymbol和typeSymbol放入当前类的env中。
env = 抽象语法树中当前节点的上下文环境信息。

插入式注解处理器可以看做是一组编译器的插件，可以读取、修改、添加抽象语法树中的任意元素；
如果这些插件对抽象语法树进行修改，那么编译器会回到解析与填充符号表的过程重新处理，直到插入式注解处理器没有再对抽象语法树进行修改。

语义分析
语法分析之后，编译器获得程序代码的抽象语法树表示，语法树表示结构正确的源程序的抽象，但无法保证源程序是否符合逻辑，语义分析主要用于对结构上正确的源程序进行上下文有关性质的检查。
语义分析由三个部分构成：

语法糖

• 泛型与类型擦除
  java语言中的泛型只在程序源码中存在，在编译后的字节码文件中，就已经被替换成原生类型，并且在相应的地方插入了强制转换。

程序源码
public static void main(String[] args){
	Map map = new HashMap();
	map.put("hello","你好");
	System.out.println(map.get("hello"));
}
泛型擦除后的代码
public static void main(String[] args){
	Map map = new HashMap(); // 泛型擦除，替换成原生类型。
	map.put("hello","你好");
	System.out.println(map.get("hello")); // 插入强制转换。
}

• 变长参数
  会变成数组类型的参数。
• 自动拆箱与装箱
  自动拆箱与装箱在编译之后会被转成对应的包装和还原方法，如 Integer.intValue() 与 Integer.valueOf(参数int)
• 遍历循环
  会变成迭代器的实现
• 条件编译
  java语言也可以进行条件编译，方法就是使用if语句，它在编译阶段被“运行”；
  java的语法糖只能是条件为常量的if语句，根据布尔值的真假，编译器会把分支中不成立的代码块消除掉。

public static void main(String[] args) {
    if(true){
        System.out.println("block 1");
    }
    else{
        System.out.println("block 2");
    }
}
 
假设结果为true，编译器会将假的值去掉，即分支中不成立的代码块去掉。
public static void main(String[] args) {
    System.out.println("block 1");
}

字节码生成
javac编译的最后一个阶段，字节码生成阶段将之前各个步骤所生成的信息转化成字节码写到磁盘中，另外进行少量的代码添加和转换工作。

java最初是通过解释器（interpreter）进行解释执行的。当虚拟机发现某方法或代码块的运行很频繁时，会把这些代码认定为“热点代码”（Hot Spot Code）。为了提高热点代码的执行效率，运行时，虚拟机会将这些代码编译成与本地平台相关的机器码，并进行各种层次的优化，完成这个任务的编译器称为即时编译器（Just In Time Compiler）

解释器与即时编译器 区别

xhj理解： 也就是说 运行期优化 说的是解释器，即及时编译期（JIT，Just In Time Compiler）。

代码：

package com.javaface5.test519.test2;
public class Test1 {
    // 逃逸分析
    public static void main(String[] args) {
        // 循环200次
        for (int i = 0; i < 200; i++) {
            // 创建1000个对象

            // 获取当前系统的时间，以纳秒单位
            long start = System.nanoTime();
            for (int j = 0; j < 1000; j++) {
                new Object(); // 循环创建对象
            }
            long end = System.nanoTime();
            System.out.printf("%dt%dn", i, (end - start));
        }
    }
}

结果分析：

0	66800
1	48600
2	53900
3	39900
-----------------------
47	63900
48	67600
49	51400
50	51900
51	45300
52	54900
-------------------
195	23300
196	24100
197	23500
198	29300
199	27800

// 相同的代码，后续执行时间越来越短。

解释：
由于即时编译器编译本地代码需要占用程序运行时间，要编译出优化程度更高的代码，所花费的时间更长；
想要编译出优化程度更高的代码，解释器还可能替编译器收集性能监控信息，对解释器执行的速度也有影响。
这也就是为什么前期运行时间长的原因。
为了在程序启动响应速度与运行效率之间达到最佳平衡，HotSpot虚拟机还会逐渐启动**分层编译（Tiered Compilation）**的策略。
JVM将执行状态分成5个层次：

profiling = 在运行过程中收集一些程序执行状态的数据，即信息统计工作（如：方法的调用次数、循环的回边次数等）。

执行效率上 解释器 < C1（提升5倍左右） < C2 （提升10-100倍）

概念：
发现方法是热点方法，且长度不长，会进行内联 = 把方法代码拷贝、粘贴到调用者的位置。
作用：
去除方法调用的成本，同时为其他优化建立了良好的基础；
各种编译器一般会把内联优化放在优化序列的最靠前位置；

代码：

package com.javaface5.test519.test2;
public class Test2 {
    // -XX:+UnlockDiagnosticVMOptions -XX:+PrintInlining    // 查看 JVM 对代码的内联情况
    // -XX:CompileCommand=dontinline,*T02_RunTime_Inlining.square   // 禁用内联
    // -XX:+PrintCompilation

    public static void main(String[] args) {
        int x = 0;
        for (int i = 0; i < 500; i++) {
            long start = System.nanoTime();
            for (int j = 0; j < 1000; j++) {
                x = square(9);
            }
            long end  = System.nanoTime();
            System.out.printf("%dt%dt%dn", i, x, (end - start));
            // 输出内容是：最外层遍历次数i 内存计算平方结果值x 最后是遍历一次的执行时间 time
        }
    }

    private static int square(final int i) {
        return i * i;
    }
}

结果分析：

0	81	225900
1	81	52200
2	81	29600
-------------------
245	81	100
246	81	100
247	81	0
248	81	0
249	81	0
250	81	100

// 输出结果：System.out.printf("%dt%dt%dn", i, x, (end - start));
// 输出内容是：最外层遍历次数i 内存计算平方结果值x 最后是遍历一次的执行时间 time

常量折叠的优化：
即编译期就把一些表达式计算好，不需要在运行时进行计算。
也就说：编译期常量加减乘除的运行过程会被折叠

1 System.out.println(square(9));
2 System.out.println(81); // 就是编译期常量加减乘除的运行过程会被折叠

String s1 = "1" + "2" ; // 字符串字面量相加
编译器会给你优化成 String s1 = "12";

String a = "a";
String bc = "bc";
String s1 = "a" + "bc" ; 
⇒ String s1 = "abc"; 编译器优化 的常量折叠 
String s2 = a + bc;
⇒ 两个非final的变来个相加，不会进行常量折叠。
被final修饰的字符串也是编译期的常量。

案例：

package com.javaface5.test520;

import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class test2 {
    public static void foo(){
        System.out.println("foo....");
    }

    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException,
            IllegalAccessException, IOException {
        Method method = test2.class.getMethod("foo");
        // 前16次调用效率较低，第17次调用效率较高
        // 因为从第17次开始，已经不是反射来调用，而是采用 类名.静态方法名 来调用了。
        // JVM虚拟机已经将我们的反射方法调用转换成 静态方法调用。
        for(int i = 0;i < 16 ; i++){
            // 按照指定格式字符串和参数将格式化的字符串写入此输出流
            System.out.printf("%dt",i);
            method.invoke(null);
        }
        System.in.read();
    }
}

图示：

PrintStream 和 InputStream
PrintStream 标准字节输出流 System.out属性 返回PrintStream对象
InputStream 字节输入流 System.in属性 返回InputStream对象
方法介绍：

参考

HotSpot采用解释器与编译器并存的框架，是因为两者皆有优势。

• 解释器：
  逐条转换，保留源代码；
  程序员可以快速启动和执行，消耗内存小；（成本低，后期效率低）
• 编译器：
  一次性转换，不保留源代码；
  随着代码频繁执行会将代码编译成本地机器码；（成本高、后期效率高）

解释器与编译器配合使用：
当程序需要迅速启动和执行的时候，解释器可以率先发挥作用，省去编译时间，立即执行；
程序运行后，随着时间的推移，编译器逐渐发挥作用，把越来越多的代码编译成本地代码后，可以提高执行效率；
当程序运行环境中内存资源限制较大，可以使用解释器执行节约内存，反之可以使用编译执行提升效率。

HotSpot
概述：它是一款及时编译器执行引擎，是目前使用范围最广的java虚拟机；

关于主内存与工作内存（线程的本地内存）之间的具体交互协议，即一个变量如何从主内存拷贝到本地内存、如何从本地内存同步回主内存的实施细节。
java内存模型定义了8种操作，每一种都是原子的，不可再分的。

需要满足的规则

• 不允许read和load、store和write操作之一单独出现，且必须保证操作执行顺序；
  且变量从主内存到工作内存 = read 和 load、变量从工作内存到主内存 = store 和 write
  表示不允许一个变量从主内存读取但是工作内存不接受，从工作内存发起写会但是主内存不接受
• 不允许一个线程丢弃它的最近的assign操作，即变量在工作内存中改变之后必须把该变化同步回主内存中；
• 不允许一个线程无原因的（没有发生任何assign操作）把数据从线程的工作内存同步回主内存中；
  即 数据从工作内存
• 一个新的变量只能在主内存中诞生，不允许在工作内存中直接使用一个未被初始化（load或assign）的变量 = 在对一个变量实施use和store操作之前，必须执行assign和load操作；（xhj：本地内存的值是别人给的，不是自己的）
• 一个变量在同一时刻只允许一条线程对其进行lock操作，但lock操作可以被同一线程重复执行多次，多次执行后，只有执行相同次数的unlock，变量才会被解锁；
• 如果一个变量执行lock操作，将会清空工作内存中此变量的值，在执行引擎使用这个变量前，需要重新load（主内存给本地）或assign（执行引擎给本地）操作初始化变量的值；
• 如果一个变量事先没有被lock操作锁定，则不允许对它执行unlock操作，也不允许去unlock一个被其他线程锁定住的变量；
• 对一个变量执行unlock操作之前，必须先把此变量同步回主内存中（执行store和write操作）；