JVM（三）：字节码与类加载
字节码指令
javap工具
Oracle提供了class文件反编译工具：javap，使用：javap -v Hello.class,即可反编译Hello.class文件。
效果如下：
1 | Classfile /D:/IDEA/Workspace/JVM/out/production/JVM/Hello.class |
方法执行流程
对于以下代码：
1 | public class Demo3_1 { |
其代码字节码如下：
1 | Code: |
其方法执行过程如下：
常量池载入运行时常量池
方法字节码载入方法区
main 线程开始运行，分配栈帧内存
（stack=2，locals=4） 对应操作数栈有2个空间（每个空间4个字节），局部变量表中有4个槽位
执行引擎开始执行字节码
bipush 10- 将一个 byte 压入操作数栈（其长度会补齐 4 个字节），类似的指令还有
- sipush 将一个 short 压入操作数栈（其长度会补齐 4 个字节）
- ldc 将一个 int 压入操作数栈
- ldc2_w 将一个 long 压入操作数栈（分两次压入，因为 long 是 8 个字节）
- 这里小的数字都是和字节码指令存在一起，超过 short 范围的数字存入了常量池
- 将一个 byte 压入操作数栈（其长度会补齐 4 个字节），类似的指令还有
istore 1- 将操作数栈栈顶元素弹出，放入局部变量表的slot 1中，对应
a = 10
- 将操作数栈栈顶元素弹出，放入局部变量表的slot 1中，对应
ldc #3读取运行时常量池中#3，即32768(超过short最大值范围的数会被放到运行时常量池中)，将其加载到操作数栈中；
注意：
Short.MAX_VALUE是 32767，所以32768 = Short.MAX_VALUE + 1实际是在编译期间计算好的。
istore 2- 将操作数栈中的元素弹出，放到局部变量表的2号位置
iload1 iload2- 因为只能在操作数栈中执行运算操作，所以这一步要将局部变量表中1号位置和2号位置的元素放入操作数栈中
iadd- 将操作数栈中的两个元素弹出栈并相加，结果在压入操作数栈中
istore 3- 将操作数栈中的元素弹出，放入局部变量表的3号位置
getstatic #4- 在运行时常量池中找到#4，发现是一个对象，在堆内存中找到该对象，并将其引用放入操作数栈中
iload 3- 将局部变量表中3号位置的元素压入操作数栈中
invokevirtual 5- 找到常量池 #5 项
- 定位到方法区
java/io/PrintStream.println:(I)V方法 - 生成新的栈帧（分配 locals、stack等）
- 传递参数，执行新栈帧中的字节码
- 执行完毕，弹出栈帧
- 清除 main 操作数栈内容
return- 完成 main 方法调用，弹出 main 栈帧
- 程序结束
字节码分析i++与++i
对于以下代码，进行分析：
1 | /** |
其字节码为：
1 | public static void main(java.lang.String[]); |
分析：
iinc指令是直接在局部变量 slot 上进行运算a++是先执行iload指令，再执行iinc指令自增；++a反之。
过程：
条件判断指令
| 指令 | 助记符 | 含义 |
|---|---|---|
| 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 用来进行跳转到指定行号的字节码。
举例：
1 | //代码： |
循环控制指令
while循环
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19//代码：
public class Demo3_4 {
public static void main(String[] args) {
int a = 0;
while (a < 10) {
a++;
}
}
}
//字节码：
0: iconst_0
1: istore_1
2: iload_1
3: bipush 10
5: if_icmpge 14
8: iinc 1, 1
11: goto 2
14: returndo-while循环
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17//代码
public class Demo3_5 {
public static void main(String[] args) {
int a = 0;
do {
a++;
} while (a < 10);
}
}
//字节码
0: iconst_0
1: istore_1
2: iinc 1, 1
5: iload_1
6: bipush 10
8: if_icmplt 2
11: returnfor循环
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16//代码
public class Demo3_6 {
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
}
}
}
//字节码
0: iconst_0
1: istore_1
2: iload_1
3: bipush 10
5: if_icmpge 14
8: iinc 1, 1
11: goto 2
14: return练习：判断以下代码输出
1
2
3
4
5
6
7
8
9
10
11public class test {
public static void main(String[] args) {
int i=0;
int x=0;
while(i<10) {
x = x++;
i++;
}
System.out.println(x); //结果为0
}
}字节码为：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18Code:
stack=2, locals=3, args_size=1 //操作数栈分配2个空间，局部变量表分配3个空间
0: iconst_0 //准备一个常数0
1: istore_1 //将常数0放入局部变量表的1号槽位 i=0
2: iconst_0 //准备一个常数0
3: istore_2 //将常数0放入局部变量的2号槽位 x=0
4: iload_1 //将局部变量表1号槽位的数放入操作数栈中
5: bipush 10 //将数字10放入操作数栈中，此时操作数栈中有2个数
7: if_icmpge 21 //比较操作数栈中的两个数，如果下面的数大于上面的数，就跳转到21。这里的比较是将两个数做减法。因为涉及运算操作，所以会将两个数弹出操作数栈来进行运算。运算结束后操作数栈为空
10: iload_2 //将局部变量2号槽位的数放入操作数栈中，放入的值是0
11: iinc 2, 1 //将局部变量2号槽位的数加1，自增后，槽位中的值为1
14: istore_2 //将操作数栈中的数放入到局部变量表的2号槽位，2号槽位的值又变为了0
15: iinc 1, 1 //1号槽位的值自增1
18: goto 4 //跳转到第4条指令
21: getstatic #2 // Field java/lang/System.out:Ljava/io/PrintStream;
24: iload_2
25: invokevirtual #3 // Method java/io/PrintStream.println:(I)V
28: return分析：
- x = 0，会将0赋值给x所在本地变量表的某个槽位；
- 由于是x++，所以是先把x的值从槽位拷贝到操作数栈；然后x再在槽位上执行自增变成1；
- 在操作数栈中，对x进行赋值操作 x = x++，操作数栈中x++的值是0，再重新赋值给x；
- x的值从自增的1，被赋值操作覆盖成了0；
- 所以不管循环赋值多少次，都是0。
构造方法
cinit()V
- 编译器会按从上至下的顺序，收集所有 static 静态代码块和静态成员赋值的代码，合并为一个特殊的方法 cinit()V ：
1 | //代码： |
init()V
- 编译器会按从上至下的顺序，收集所有 {} 代码块和成员变量赋值的代码，形成新的构造方法，但原始构造方法内的代码总是在后。
1 | //代码： |
方法调用
规则：
new是创建对象，给对象分配堆内存，执行成功会将对象引用压入操作数栈；dup是复制操作数栈栈顶的内容，本例即为对象引用，为什么需要额外复制引用呢，一个是要配合invokespecial调用该对象的构造方法"<init>":()V（会消耗掉栈顶一个引用），另一个要配合astore_1赋值给局部变量；- 最终方法（final），私有方法（private），构造方法都是由
invokespecial指令来调用，属于静态绑定； - 普通成员方法是由
invokevirtual调用，属于动态绑定，即支持多态； - 成员方法与静态方法调用的另一个区别是，执行方法前是否需要对象引用，即观察是否需要执行
aload_1； - 还有一个执行
invokespecial的情况是通过 super 调用父类方法。
代码示例：1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35//代码；
public class test {
public test() {}
private void test1() { }
private final void test2() {}
public void test3() {}
public static void test4() {}
public static void main(String[] args) {
test demo5 = new test();
demo5.test1();
demo5.test2();
demo5.test3();
test.test4();
}
}
//字节码：
Code:
stack=2, locals=2, args_size=1
0: new #2 // class test
3: dup
4: invokespecial #3 // Method "<init>":()V
7: astore_1
8: aload_1
9: invokespecial #4 // Method test1:()V
12: aload_1
13: invokespecial #5 // Method test2:()V
16: aload_1
17: invokevirtual #6 // Method test3:()V
20: invokestatic #7 // Method test4:()V
23: return
多态原理
因为普通成员方法需要在运行时才能确定具体的内容，所以虚拟机需要调用invokevirtual指令。
在执行invokevirtual指令时，经历了以下几个步骤:
- 先通过栈帧中对象的引用找到对象
- 分析对象头，找到对象实际的Class
- Class结构中有vtable
- 查询vtable找到方法的具体地址
- 执行方法的字节码
异常处理
try-catch
规则：
- 可以看到多出来一个 Exception table 的结构，[from, to) 是左闭右开（也就是检测2~4行）的检测范围，一旦这个范围内的字节码执行出现异常，则通过 type 匹配异常类型，如果一致，进入 target 所指示行号；
- 8行的字节码指令 astore_2 是将异常对象引用存入局部变量表的2号位置（为e）。
代码示例：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27//代码
public class test {
public static void main(String[] args) {
int i = 0;
try {
i = 10;
}catch (Exception e) {
i = 20;
}
}
}
//字节码：
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
多个single-catch
规则：
- 异常出现时，只能进入 Exception table 中一个分支，所以局部变量表 slot 2 位置被共用。
代码示例：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33//代码：
public class test {
public static void main(String[] args) {
int i = 0;
try {
i = 10;
}catch (ArithmeticException e) {
i = 20;
}catch (Exception e) {
i = 30;
}
}
}
//字节码：
Code:
stack=1, locals=3, args_size=1
0: iconst_0
1: istore_1
2: bipush 10
4: istore_1
5: goto 19
8: astore_2
9: bipush 20
11: istore_1
12: goto 19
15: astore_2
16: bipush 30
18: istore_1
19: return
Exception table:
from to target type
2 5 8 Class java/lang/ArithmeticException
2 5 15 Class java/lang/Exception
finally
规则：
- finally 中的代码会被复制 n 份，分别放入 try 流程，catch 流程以及 catch剩余的异常类型流程；
- 虽然从字节码指令看来，每个块中都有finally块，但是finally块中的代码只会被执行一次。
代码示例：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45//代码：
public class test {
public static void main(String[] args) {
int i = 0;
try {
i = 10;
} catch (Exception e) {
i = 20;
} finally {
i = 30;
}
}
}
//字节码：
Code:
stack=1, locals=4, args_size=1
0: iconst_0
1: istore_1
//try块
2: bipush 10
4: istore_1
//try块执行完后，会执行finally
5: bipush 30
7: istore_1
8: goto 27
//catch块
11: astore_2 //异常信息放入局部变量表的2号槽位
12: bipush 20
14: istore_1
//catch块执行完后，会执行finally
15: bipush 30
17: istore_1
18: goto 27
//出现异常，但未被Exception捕获，会抛出其他异常，这时也需要执行finally块中的代码
21: astore_3
22: bipush 30
24: istore_1
25: aload_3
26: athrow //抛出异常
27: return
Exception table:
from to target type
2 5 11 Class java/lang/Exception
2 5 21 any
11 15 21 any
finally中的return
代码示例：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30//代码：
public class test {
public static void main(String[] args) {
int i = test.test1();
//结果为20
System.out.println(i);
}
public static int test1() {
try {
return 10;
} finally {
return 20;
}
}
}
//字节码：
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规则：
- 由于 finally 中的 ireturn 被插入了所有可能的流程，因此返回结果以finally的为准；
- 字节码第二行的作用是暂存try中的返回值；
- 跟上例中的 finally 相比，发现没有 athrow 了，这告诉我们：如果在 finally 中出现了 return，会吞掉异常（如下段代码），所以不要在finally中进行返回操作。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21//该段代码本应该抛出异常，但由于finally中带return，所以异常被吞了
public class test {
public static void main(String[] args) {
int i = test.test1();
//最终结果为20
System.out.println(i);
}
public static int test1() {
int i;
try {
i = 10;
//这里应该会抛出异常
i = i/0;
return i;
} finally {
i = 20;
return i;
}
}
}
finally中不带return
代码示例：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35//代码：
public class test {
public static void main(String[] args) {
int result = test1();
System.out.println(result);//10
}
public static int test1() {
int i = 10;
try {
return i;
} finally {
i = 20;
}
}
}
//字节码：
Code:
stack=1, locals=3, args_size=0
0: bipush 10
2: istore_0 //赋值给i 10
3: iload_0 //加载到操作数栈顶
4: istore_1 //加载到局部变量表的1号位置
5: bipush 20
7: istore_0 //赋值给i 20
8: iload_1 //加载局部变量表1号位置的数10到操作数栈
9: ireturn //返回操作数栈顶元素 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规则：
- finally中的赋值语句不会影响try中的return：try中将要返回的值会被暂存在临时变量表中，即使finally中改变了返回值，也不会影响最终返回的值。
Synchronized
代码示例：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45//代码：
public class test {
public static void main(String[] args) {
int i = 10;
Lock lock = new Lock();
synchronized (lock) {
System.out.println(i);
}
}
}
class Lock{}
//字节码：
Code:
stack=2, locals=5, args_size=1
0: bipush 10
2: istore_1
3: new #2 // class com/nyima/JVM/day06/Lock
6: dup //复制一份，放到操作数栈顶，用于构造函数消耗
7: invokespecial #3 // Method com/nyima/JVM/day06/Lock."<init>":()V
10: astore_2 //剩下的一份放到局部变量表的2号位置
11: aload_2 //加载到操作数栈
12: dup //复制一份，放到操作数栈，用于加锁时消耗
13: astore_3 //将操作数栈顶元素弹出，暂存到局部变量表的三号槽位。这时操作数栈中有一份对象的引用
14: monitorenter //加锁
//锁住后代码块中的操作
15: getstatic #4 // Field java/lang/System.out:Ljava/io/PrintStream;
18: iload_1
19: invokevirtual #5 // Method java/io/PrintStream.println:(I)V
//加载局部变量表中三号槽位对象的引用，用于解锁
22: aload_3
23: monitorexit //解锁
24: goto 34
//异常操作
27: astore 4
29: aload_3
30: monitorexit //解锁
31: aload 4
33: athrow
34: return
//可以看出，无论何时出现异常，都会跳转到27行，将异常放入局部变量中，并进行解锁操作，然后加载异常并抛出异常。
Exception table:
from to target type
15 24 27 any
27 31 27 any规则：
- 由字节码可知，即使出异常，也会正确的进行解锁操作。
编译期处理
编译器处理即语法糖，是指 java 编译器把 .java 源码编译为 \.class 字节码的过程中，自动生成和转换的一些代码，主要是为了减轻程序员的负担。
以下代码的分析，借助了 javap 工具，idea 的反编译功能，idea 插件 jclasslib 等工具。另外，编译器转换的结果直接就是 class 字节码，只是为了便于阅读，给出了 几乎等价 的 java 源码方式，并不是编译器还会转换出中间的 java 源码。
默认构造函数
1 | //代码： |
自动拆装箱
1 | //代码： |
泛型集合取值
泛型是在 JDK 5 开始加入的特性，但 java 在编译泛型代码后会执行 泛型擦除 的动作，即泛型信息在编译为字节码之后就丢失了，实际的类型都当做了 Object 类型来处理，如下代码：
1 | //代码： |
由以上字节码可知：
- 在调用get函数取值时，会进行类型转换：
Integer x = (Integer) list.get(0); - 若要将返回结果赋值给一个int类型的变量，则还有自动拆箱的操作：
int x = (Integer) list.get(0).intValue();。
可变参数
由赋值语句可知：可变参数String… args是一个String[] args，所以编译器会在编译期间进行转换。
1 | //代码: |
foreach
数组进行foreach遍历
1 | //代码： |
集合进行foreach遍历
集合要使用foreach，需要该集合类实现了Iterable接口，因为集合的遍历需要用到迭代器Iterator。
1 | //代码： |
switch
switch字符串
运行过程：
在编译期间，单个的switch被分为了两个：
- 第一个用来匹配字符串，并给x赋值
- 字符串的匹配用到了字符串的hashCode，还用到了equals方法
- 使用hashCode是为了提高比较效率，使用equals是防止有hashCode冲突（如BM和C.）
- 第二个用来根据x的值来决定输出语句
- 第一个用来匹配字符串，并给x赋值
代码：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57//代码：
public class Demo6 {
public static void main(String[] args) {
String str = "hello";
switch (str) {
case "hello" :
System.out.println("h");
break;
case "world" :
System.out.println("w");
break;
default:
break;
}
}
}
//编译器优化：
public class Demo6 {
public Demo6() {
}
public static void main(String[] args) {
String str = "hello";
int x = -1;
//通过字符串的hashCode+value来判断是否匹配
switch (str.hashCode()) {
//hello的hashCode
case 99162322 :
//再次比较，因为字符串的hashCode有可能相等
if(str.equals("hello")) {
x = 0;
}
break;
//world的hashCode
case 11331880 :
if(str.equals("world")) {
x = 1;
}
break;
default:
break;
}
//用第二个switch在进行输出判断
switch (x) {
case 0:
System.out.println("h");
break;
case 1:
System.out.println("w");
break;
default:
break;
}
}
}
switch枚举
运行过程：
- 定义一个合成类（仅 jvm 使用，对我们不可见）用来映射枚举的 ordinal 与数组元素的关系；
- 枚举的 ordinal 表示枚举对象的序号，从 0 开始，即 MALE 的 ordinal()=0，FEMALE 的 ordinal()=1；
- case再通过对象在数组中的位置判断输出。
代码：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54//代码：
public class Demo7 {
public static void main(String[] args) {
SEX sex = SEX.MALE;
switch (sex) {
case MALE:
System.out.println("man");
break;
case FEMALE:
System.out.println("woman");
break;
default:
break;
}
}
}
enum SEX {
MALE, FEMALE;
}
//编译器优化；
public class Demo7 {
//定义合成类
static class $MAP {
//数组大小即为枚举元素个数，里面存放了case用于比较的数字
static int[] map = new int[2];
static {
//ordinal即枚举元素对应所在的位置，MALE为0，FEMALE为1
map[SEX.MALE.ordinal()] = 1;
map[SEX.FEMALE.ordinal()] = 2;
}
}
public static void main(String[] args) {
SEX sex = SEX.MALE;
//将对应位置枚举元素的值赋给x，用于case操作
int x = $MAP.map[sex.ordinal()];
switch (x) {
case 1:
System.out.println("man");
break;
case 2:
System.out.println("woman");
break;
default:
break;
}
}
}
enum SEX {
MALE, FEMALE;
}
枚举类
1 | //代码： |
匿名内部类
常规：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29//代码；
public class Demo8 {
public static void main(String[] args) {
Runnable runnable = new Runnable() {
public void run() {
System.out.println("running...");
}
};
}
}
//优化：
public class Demo8 {
public static void main(String[] args) {
//用额外创建的类来创建匿名内部类对象
Runnable runnable = new Demo8$1();
}
}
//创建了一个额外的类，实现了Runnable接口
final class Demo8$1 implements Runnable {
public Demo8$1() {}
public void run() {
System.out.println("running...");
}
}若匿名内部类中引用了局部变量
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39//代码：
public class Demo8 {
public static void main(String[] args) {
int x = 1;
Runnable runnable = new Runnable() {
public void run() {
System.out.println(x);
}
};
}
}
//优化：
public class Demo8 {
public static void main(String[] args) {
int x = 1;
Runnable runnable = new Runnable() {
public void run() {
System.out.println(x);
}
};
}
}
final class Demo8$1 implements Runnable {
//多创建了一个变量
int val$x;
//变为了有参构造器
public Demo8$1(int x) {
this.val$x = x;
}
public void run() {
System.out.println(val$x);
}
}
类加载机制
类加载阶段
加载
- 在加载阶段，需要完成以下事情：
- 通过一个类的全限定名来获取定义此类的二进制字节流。
- 将这个字节流所代表的静态存储结构转化为方法区的运行时数据结构。
- 在内存中生成一个代表这个类的
java.lang.Class对象，作为方法区这个类的各种数据的访问入口。
- TIPS：
- 相对于类加载过程的其他阶段，非数组类型的加载阶段（准确地说，是加载阶段中获取类的二进制字节流的动作）是开发人员可控性最强的阶段，因为开发人员既可以使用系统提供的类加载器来完成加载，也可以自定义自己的类加载器来完成加载；
- 对于数组类而言，情况就有所不同，数组类本身不通过类加载器创建，它是由Java虚拟机直接在内存中动态构造出来的；
- 加载阶段完成后，虚拟机外部的二进制字节流就按照虚拟机所需的格式存储在方法区中，而且Java堆中也创建一个
java.lang.Class类的对象，这样便可以通过该对象访问方法区中的这些数据； - 加载和链接可能是交替运行的。
链接
连接阶段可以细分为验证、准备、解析三个阶段。
验证
- 作用：验证确保被用户加载的类的正确性，是连接阶段的第一步，这一阶段的目的是为了确保Class文件的字节流中包含的信息符合当前虚拟机的要求，并且不会危害虚拟机自身的安全。
- 验证阶段大致会完成4个阶段的检验工作：
- 文件格式验证：验证字节流是否符合Class文件格式的规范；例如：是否以 0xCAFEBABE开头、主次版本号是否在当前虚拟机的处理范围之内、常量池中的常量是否有不被支持的类型。
- 元数据验证：对字节码描述的信息进行语义分析（注意：对比javac编译阶段的语义分析），以保证其描述的信息符合Java语言规范的要求；例如：这个类是否有除了 java.lang.Object 之外的父类。
- 字节码验证：该阶段验证的主要工作是进行数据流和控制流分析，对类的方法体进行校验分析，以保证被校验的类的方法在运行时不会做出危害虚拟机安全的行为。
- 符号引用验证：这是最后一个阶段的验证，它发生在虚拟机将符号引用转化为直接引用的时候（解析阶段中发生该转化，后面会有讲解），主要是对类自身以外的信息（常量池中的各种符号引用）进行匹配性的校验，确保解析动作能正确执行。
- 关闭：验证阶段不是必须的，关闭它可以类加载的时间。参数：
-Xverify:none。
准备
作用：为 static 变量分配空间，设置默认值。
TIPS：
默认赋予零值：
对于类变量（static）和全局变量的基本类型来说，如果不显式地对其赋值而直接使用，系统会为其赋值默认的零值；
对于引用数据类型reference来说，如数组引用、对象引用等，如果没有对其进行显式地赋值而直接使用，系统都会为其赋予默认的零值，即null；
如果在数组初始化时没有对数组中的各个元素赋值，那么其中的元素将根据对应的数据类型而被赋予默认的零值。
使用前需要显式地赋值：
- 对于局部变量的基本类型来说来说，在使用前必须显式地为其赋值，否则编译时不通过；
- 只被final修饰的常量既可以在声明时显式地为其赋值，也可以在类初始化时显式地为其赋值，总之，在使用前必须为其显式地赋值，系统不会为其赋值默认零值。
同时被static和final修饰即常量属性，必须在声明的时候就为其显式地赋值，否则编译时不通过，常量属性在准备阶段该常量就会被初始化为其对应的值。
static变量在分配空间和赋值是在两个阶段完成的。分配空间在准备阶段完成，赋值在初始化阶段完成；
如果 static 变量是 final 的基本类型，以及字符串常量，那么编译阶段值就确定了，赋值在准备阶段完成，如果 static 变量是 final 的，但属于引用类型，那么赋值也会在初始化阶段完成。
解析
作用：将常量池中的符号引用解析为直接引用。（未解析时，常量池中的看到的对象仅是符号，未真正的存在于内存中）
四种引用的解析过程：
类或接口：判断所要转化成的直接引用是对数组类型，还是普通的对象类型的引用，从而进行不同的解析。
字段：对字段进行解析时，会先在本类中查找是否包含有简单名称和字段描述符都与目标相匹配的字段，如果有，则查找结束；如果没有，则会按照继承关系从上往下递归搜索该类所实现的各个接口和它们的父接口，还没有，则按照继承关系从上往下递归搜索其父类，直至查找结束。如下代码演示：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32/**
* 测试解析阶段：
* 1. 当前代码运行结果为：
* 执行了 Super 类静态语句块
* 执行 Father 静态语句块
* 2
* 2. 如果注释了Father类中的第一行，则运行结果为：
* 执行了 Super 类静态语句块
* 456
*/
public class StaticTest {
public static void main(String[] args) {
System.out.println(Child.m);
}
}
class Child extends Father{
static{
System.out.println("执行 Child 类静态语句块");
}
}
class Father extends Super {
public static int m = 2;
static {
System.out.println("执行 Father 静态语句块");
}
}
class Super{
public static int m = 1;
static{
System.out.println("执行了 Super 类静态语句块");
}
}类方法：对类方法的解析与对字段解析的搜索步骤差不多，只是多了判断该方法所处的是类还是接口的步骤，而且对类方法的匹配搜索，是先搜索父类，再搜索接口。
接口方法：与类方法解析步骤类似，知识接口不会有父类，因此，只递归向上搜索父接口就行了。
初始化
作用：初始化阶段就是执行类构造器clinit()方法的过程，虚拟机会保证这个类的『构造方法』的线程安全。
clinit()方法是由编译器自动收集类中的所有类变量的赋值动作和静态语句块（static{}块）中的语句合并产生的，并且顺序是由语句在源文件中出现的顺序决定的，所以静态语句块中只能访问到定义在静态语句块之前的变量，定义在它之后的变量，在前面的静态语句块可以赋值，但是不能访问，例子如下：发生时机：
- 类的初始化的懒惰的，以下情况会初始化：
- main 方法所在的类，总会被首先初始化；
- 首次访问这个类的静态变量或静态方法时；
- 子类初始化，如果父类还没初始化，会引发；
- 子类访问父类的静态变量，只会触发父类的初始化；
- Class.forName；
- new 会导致初始化。
- 以下情况不会初始化：
- 访问类的 static final 静态常量（基本类型和字符串）；
- 类对象.class 不会触发初始化；
- 创建该类对象的数组；
- 类加载器的.loadClass方法；
- Class.forNamed的参数2为false时。
- 类的初始化的懒惰的，以下情况会初始化：
类加载器
Java虚拟机设计团队有意把类加载阶段中的“通过一个类的全限定名来获取描述该类的二进制字节流”这个动作放到Java虚拟机外部去实现，以便让应用程序自己决定如何去获取所需的类。实现这个动作的代码被称为“类加载器”（ClassLoader）1。
类与类加载器
关系：类加载器虽然只用于实现类的加载动作，但它在 Java 程序中起到的作用却远超类加载阶段。对于任意一个类，都必须由加载它的类加载器和这个类本身一起共同确立其在Java虚拟机中的唯一性，每一个类加载器，都拥有一个独立的类名称空间。这句话可以表达得更通俗一些：比较两个类是否“相等”，只有在这两个类是由同一个类加载器加载的前提下才有意义，否则，即使这两个类来源于同一个 Class 文件，被同一个 Java 虚拟机加载，只要加载它们的类加载器不同，那这两个类就必定不相等。1
JDK8中的类加载器：
| 名称 | 加载的类 | 说明 |
| ————————————————————- | ——————————- | ———————————————- |
| Bootstrap ClassLoader（启动类加载器） | JAVA_HOME/jre/lib | 无法直接访问 |
| Extension ClassLoader(扩展类加载器) | JAVA_HOME/jre/lib/ext | 上级为Bootstrap，显示为null |
| Application ClassLoader(应用程序类加载器) | classpath | 上级为Extension |
| 自定义类加载器 | 自定义 | 上级为Application |类加载器的层次关系
有以下代码：
1
2
3
4
5
6
7
8
9
10
11
12
13
14public class ClassLoaderTest {
public static void main(String[] args) {
ClassLoader loader = Thread.currentThread().getContextClassLoader();
System.out.println(loader);
System.out.println(loader.getParent());
System.out.println(loader.getParent().getParent());
/**
* 运行后输出结果
* sun.misc.Launcher$AppClassLoader@18b4aac2
* sun.misc.Launcher$ExtClassLoader@61bbe9ba
* null
*/
}
}说明类加载器的层次关系如下图所示：
双亲委派模型
双亲委派模式，即调用类加载器ClassLoader 的 loadClass 方法时，查找类的规则。
注意：双亲委派模型要求除了顶层的启动类加载器外，其余的类加载器都应有自己的父类加载器。不过这里类加载器之间的父子关系一般不是以继承（Inheritance）的关系来实现的，而是通常使用组合（Composition）关系来复用父加载器的代码。
工作流程：如果一个类加载器收到了类加载的请求，它首先不会自己去尝试加载这个类，而是把这个请求委派给父类加载器去完成，每一个层次的类加载器都是如此，因此所有的加载请求最终都应该传送到最顶层的启动类加载器中，只有当父加载器反馈自己无法完成这个加载请求（它的搜索范围中没有找到所需的类）时，子加载器才会尝试自己去完成加载。
loadClass源码：1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37protected Class<?> loadClass(String name, boolean resolve)
throws ClassNotFoundException
{
synchronized (getClassLoadingLock(name)) {
// 首先查找该类是否已经被该类加载器加载过了
Class<?> c = findLoadedClass(name);
//如果没有被加载过
if (c == null) {
long t0 = System.nanoTime();
try {
//看是否被它的上级加载器加载过了 Extension的上级是Bootstarp，但它显示为null
if (parent != null) {
c = parent.loadClass(name, false);
} else {
//看是否被启动类加载器加载过
c = findBootstrapClassOrNull(name);
}
} catch (ClassNotFoundException e) {
// ClassNotFoundException thrown if class not found
// from the non-null parent class loader
//捕获异常，但不做任何处理
}
if (c == null) {
//如果还是没有找到，先让拓展类加载器调用findClass方法去找到该类，如果还是没找到，就抛出异常
//然后让应用类加载器去找classpath下找该类
long t1 = System.nanoTime();
c = findClass(name);
}
}
if (resolve) {
resolveClass(c);
}
return c;
}
}
自定义类加载器
- 使用场景：
- 想加载非 classpath 随意路径中的类文件；
- 通过接口来使用实现，希望解耦时，常用在框架设计；
- 这些类希望予以隔离，不同应用的同名类都可以加载，不冲突，常见于 tomcat 容器。
- 步骤：
- 继承ClassLoader父类；
- 要遵从双亲委派机制，重写
findClass方法（不是重写loadClass方法，否则不会走双亲委派机制）； - 读取类文件的字节码；
- 调用父类的 defineClass 方法来加载类；
- 使用者调用该类加载器的 loadClass 方法。
破坏双亲委派模型
- 双亲委派模型的第一次“被破坏”其实发生在双亲委派模型出现之前——即JDK1.2面世以前的“远古”时代，建议用户重写findClass()方法，在类加载器中的loadClass()方法中也会调用该方法。
- 双亲委派模型的第二次“被破坏”是由这个模型自身的缺陷导致的，如果有基础类型又要调用回用户的代码，此时也会破坏双亲委派模式。
- 双亲委派模型的第三次“被破坏”是由于用户对程序动态性的追求而导致的，这里所说的“动态性”指的是一些非常“热”门的名词：代码热替换（Hot Swap）、模块热部署（Hot Deployment）等。
本博客所有文章除特别声明外，均采用 CC BY-NC-SA 4.0 许可协议。转载请注明来自 一袖南烟顾！
评论