短时间洞察Java虚拟机——第二部分
Java类加载器
类的生命周期与加载进程
- 加载：将所有的.class文件、jar文件或网络流中的内容转化为字节流，这一过程由JVM与java.lang.ClassLoader协同完成，最终存储于Metaspace/Method Area区域。
- 校验：对class文件的字节流信息进行检查，确保其符合当前虚拟机的要求，保障虚拟机的安全。
- 准备：为类中的变量设置默认值，并分配相应的内存空间。
- 解析：把常量池中的符号引用转换为直接引用，主要涵盖类或接口的解析、字段解析、类方法解析以及接口方法解析等，为后续的初始化和运行提供直接引用依据。
- 初始化：执行类构造器
<clinit>方法来完成类的初始化操作。
类加载的时机
📖
* 启动包含main方法的类时。
* 创建类的实例对象时。
* 调用类的静态方法时。
* 访问类的静态成员时。
* 子类进行初始化时会触发父类的初始化。
* 类进行初始化时会引发接口的初始化。
* 初次调用Method Handle方法时。
📖
* 引用父类的静态字段，不会触发子类的初始化。
* 定义对象数组，不会触发对象的初始化。
* 调用常量，不会引发类的初始化。
* ClassLoader.loadClass方法仅执行类的加载操作，不会进行初始化。
类加载机制
⚙
* 启动类加载器（bootstrap class loader）：用于加载Java的核心类（由C++编写），是JVM自带的加载器。例如，java.lang.String类就是由启动类加载器加载的，所以String.class.getClassLoader()会返回null。
* 扩展类加载器（extensions class loader）：负责加载JRE的扩展目录下的类，由启动类加载器进行加载。
* 应用类加载器（app class loader）：通过ClassLoader.getSystemClassLoader()方法获取，若未特别指定自定义类加载器，用户自定义的类通常由该加载器进行加载。
📖
* 双亲委托：加载所需类时采用懒加载策略，将加载相关类的任务委托给父类加载器来负责依赖关系的处理。
* 负责依赖：在加载所需类时，会同时加载相关的依赖类和接口。
* 缓存加载：类被加载后会被缓存起来。
JVM方法调用
方法在JVM中的构成包括类名、方法名以及方法描述符（由参数类型和返回参数类型组成）。
静态方法
invokestatic指令，用于调用某个类的静态方法，是方法调用指令中执行速度较快的一种。invokespecial指令，我们已经了解过，它可以用来调用构造函数，也能用于调用同一个类中的private方法以及可见的超类方法。
动态调用
invokevirtual指令，当目标对象是具体类型时，该指令用于调用公共、受保护和打包私有的方法。invokeinterface指令，当要调用的方法属于某个接口时，会使用该指令。
JVM方法查询
子类的静态方法会隐藏（需注意与重写区分）父类中同名且同描述符的静态方法，接口也同理
📖
1. 在C类中查找符合名字及描述符的方法。
2. 如果在C类中未找到，就在C类的父类中继续搜索，直至Object类。
3. 如果还未找到，就在C类直接实现或间接实现的接口中进行搜索，搜索到的目标方法必须是非私有且非静态的。并且，如果目标方法在间接实现的接口中，需满足C类与该接口之间不存在其他符合条件的目标方法。若存在多个符合条件的目标方法，任意返回其中一个即可。
虚方法调用
- 虚拟方法表：在链接阶段会建立class的虚方法（非static、final）表。
分离invokinterface与invokevirtual的原因
class A
1: method1
2: method2
class B extends A
1: method1
2: method2
3: method3
class B extends A implements X
1: method1
2: method2
3: method3
4: methodX
class C implements X
1: methodC
2: methodX
- 内联缓存：
* -只是缓存并非内联（嵌入内部）
在执行过程中，如果遇到已缓存的类型，内联缓存会直接调用该类型对应的目标方法。
💡
* 单态内联：缓存了一种动态类型及其对应的目标方法。
* 多态内联：缓存多种…，常用于热门方法的前期调用。
- 劣化为超多态状态
💡
当类型切换过于频繁（超多态）时，缓存的维护成本（写开销）超过收益，JVM会选择放弃缓存。
JVM处理异常
异常基本概念
💡
* 抛出异常：包括应用层面的显示抛出和JVM层面的隐式抛出。
* 异常捕获：
* try代码块用于标记需要进行异常监控的代码。
* catch代码块用于捕获异常。
try代码块后可跟随多个catch代码块，用于捕获不同类型的异常，Java虚拟机会从上至下匹配异常处理器。
* finally代码块用于声明一段必定会执行的代码。
因为异常具有动态性和实时性，所以通常使用new exception()来创建异常对象。
💡
* Error：其执行状态已无法恢复，需要中止线程甚至是中止虚拟机，错误的运行会影响到全局代码。
* Exception：涵盖程序可能需要捕获（通过try – catch）并处理的异常。
* RuntimeException：属于局部的、可恢复的异常，通过适当的错误处理，程序可以继续运行。
如何捕获异常
每个method都会维护一张Exception table
Exception table:
from to target type
0 3 6 Class java/lang/Exception
⚙
当程序触发异常时，会自上到下遍历异常表中的条目，若命中相应条目，将PC指向target，否则照常抛出异常。
Java 7 的 Suppressed 异常以及语法糖
📌
语法糖具有以下特点：
* 可读性强：使代码更接近人类语言，便于理解。
* 非必需：去掉语法糖后，语言仍能实现相同功能，只是写法更复杂。
* 编译器/解释器处理：语法糖通常在编译或解释时被转换为更基础的代码。
📖
Java 7专门构造了try-with-resources语法糖，在字节码层面自动使用Suppressed异常来解决代码繁琐的问题，示例如下：
try {
in0 = new FileInputStream(new File("in0.txt"));
...
try {
in1 = new FileInputStream(new File("in1.txt"));
...
try {
in2 = new FileInputStream(new File("in2.txt"));
...
} finally {
if (in2 != null) in2.close();
}
} finally {
if (in1 != null) in1.close();
}
} finally {
if (in0 != null) in0.close();
try (Foo foo0 = new Foo("Foo0"); // try-with-resources语法糖优化后
Foo foo1 = new Foo("Foo1"); // 该语法糖下自动使用suppressed异常
Foo foo2 = new Foo("Foo2")) {
throw new RuntimeException("Initial");
}
**suppressed异常**允许将一个异常附于另一个异常之上，因此，抛出的异常可以附带多个异常的信息。
JVM实现反射机制
依赖于JVM的类加载器和运行时数据结构（如方法表、字段表）
怎么用
📖
通常使用反射API的第一步是获取Class对象，在Java中常见的有以下三种方式。
1. 使用静态方法Class.forName来获取。
2. 调用对象的getClass()方法。
3. 直接通过类名+“.class”进行访问。对于基本类型来说，它们的包装类型拥有一个名为“TYPE”的final静态字段，指向该基本类型对应的Class对象，例如int[].class。
📌
1. 使用newInstance()来生成该类的一个实例，这要求该类中存在一个无参数的构造器。
2. 使用isInstance(Object)来判断一个对象是否为该类的实例，语法上等同于instanceof关键字（JIT优化时会有差异，会在本专栏第二部分详细介绍）。
3. 使用Array.newInstance(Class,int)来构造该类型的数组。
4. 使用getFields()/getConstructors()/getMethods()来访问该类的成员。除了这三个方法外，Class类还提供了许多其他方法，详情可参考[4]。需要注意的是，方法名中带Declared的不会返回父类的成员，但会返回私有成员；而不带Declared的则相反。
📌
当获取到类成员后，可进行以下操作：
* 使用Constructor/Field/Method.setAccessible(true)来绕过Java语言的访问限制。
* 使用Constructor.newInstance(Object[])来生成该类的实例。
* 使用Field.get/set(Object)来访问字段的值。
* 使用Method.invoke(Object, Object[])来调用方法。
应用
- IDE：每当敲入点号时，IDE会根据点号前的内容，动态展示可访问的字段或方法。
- Java调试器：在调试过程中可以枚举某一对象所有字段的值。
- Spring framework：用于IOC（控制反转）。
Method.invoke
本地实现、委派实现、动态实现（均由MethodAccessor抽象）
getMethod会形成一份class内方法的拷贝 -避免在热点代码中使用getMethod
取消委派实现，关闭检查时目标方法的权限可以小幅度提升性能
public final class Method extends Executable {
...
public Object invoke(Object obj, Object... args) throws ... {
... // 权限检查
MethodAccessor ma = methodAccessor;
if (ma == null) {
ma = acquireMethodAccessor();
}
return ma.invoke(obj, args);
}
}
-
本地实现
// v0 版本
import java.lang.reflect.Method;public class Test {
public static void target(int i) {
new Exception(“#” + i).printStackTrace();
}public static void main(String[] args) throws Exception {
Class<?> klass = Class.forName(“Test”);
Method method = klass.getMethod(“target”, int.class);
method.invoke(null, 0);
}
}不同版本的输出略有不同，这里使用了Java 10。
$ java Test
java.lang.Exception: #0
at Test.target(Test.java:5)
本地实现 at java.base/jdk.internal.reflect.NativeMethodAccessorImpl .invoke0(Native Method)
↑ at java.base/jdk.internal.reflect.NativeMethodAccessorImpl. .invoke(NativeMethodAccessorImpl.java:62)
委派实现 at java.base/jdk.internal.reflect.DelegatingMethodAccessorImpl.i .invoke(DelegatingMethodAccessorImpl.java:43)
↑
invoke at java.base/java.lang.reflect.Method.invoke(Method.java:564)
at Test.main(Test.java:131 -
委派实现：作为invoke实现的中间件，用于选择method invoke本地实现还是动态实现。
-
动态实现（纯java字节码，无需重新从java→c++→java）：优势在于避免了JNI（java native interface）的切换开销，但缺点是生成字节码耗时。
// 动态实现的伪代码，这里仅列举关键调用逻辑，实际还包括调用者检测、参数检测的字节码。
package jdk.internal.reflect;public class GeneratedMethodAccessor1 extends … {
@Overrides
public Object invoke(Object obj, Object[] args) throws … {
Test.target((int) args[0]);
return null;
}
}
💡
当本地实现某一方法的次数大于Dsun.reflect.inflationThreshold时，JVM虚拟机会开始对反射method以java字节码形成动态实现。
Method method1 = Test.class.getMethod("target", int.class);
Method method2 = Test.class.getMethod("target", int.class);
📖
每次get都会创建一个新的method实例，即使访问的方法相同，method1也不等于method2。
JVM实现invokedynamic
方法句柄(Method Handle)
💡
* 通过MethodHandles.Lookup类完成，它提供了多个API，既可以使用反射API中的Method来查找，也能根据类、方法名以及方法调用类型来查找。
* Lookup.findStatic、Lookup.findVirtual、Lookup.findSpecial
* 方法句柄的类型(MethodType)仅由Method的参数类型和返回类型决定。
class Foo {
private static void bar(Object o) {
..
}
public static Lookup lookup() {
return MethodHandles.lookup();
}
}
// 获取方法句柄的不同方式
MethodHandles.Lookup l = Foo.lookup(); // 具备Foo类的访问权限
Method m = Foo.class.getDeclaredMethod("bar", Object.class);
MethodHandle mh0 = l.unreflect(m);
MethodType t = MethodType.methodType(void.class, Object.class);
MethodHandle mh1 = l.findStatic(Foo.class, "bar", t);
⚙
* 方法句柄同样会检查权限，但相比于反射，其权限检查在创建阶段完成，无需每次使用时重复检查。
* 方法句柄的访问权限不取决于方法句柄的创建位置，而是取决于Lookup对象的创建位置。
方法句柄的操作
📌
严格匹配传入参数类型的invokeExact，只接受相同类型（Object）String→Object，不允许String→Object。
@PolymorphicSignatur实现签名多态性，可根据传入参数不同自动创建不同的方法句柄。
📌
如果需要自动适配参数类型，可选取方法句柄的第二种调用方式invoke，它同样是一个签名多态性的方法。invoke会调用MethodHandle.asType方法，生成一个适配器方法句柄，对传入的参数进行适配，再调用原方法句柄。调用原方法句柄的返回值也会先进行适配，然后再返回给调用者。
📖
方法句柄还支持增删改参数的操作，这些操作通过生成另一个方法句柄来实现。其中，改操作是通过MethodHandle.asType方法实现的；删操作是将传入的部分参数就地抛弃，对应的API是MethodHandles.dropArguments方法；增操作则是往传入的参数中插入额外的参数，对应的API是MethodHandle.bindTo方法。Java 8中捕获类型的Lambda表达式就是用这种操作来实现的，下一篇会详细解释。增操作还可用于实现方法的柯里化[3]，例如有一个指向f(x, y)的方法句柄，将x绑定为4，可生成另一个方法句柄g(y) = f(4, y)，执行时会在参数列表最前面插入一个4，再调用指向f(x, y)的方法句柄。
如果你看完了，非常感谢你对我付出的认可🥰🥰🥰😘😘😘
