(拉钩)Android工程师进阶34讲-06:Class对象在执行引擎中的初始化过程

0. 前言

前面介绍了ClassLoader的使用,包括它的主要作用就是用来将class字节码加载到内存中。那么,JVM加载class文件的具体过程是怎么样的呢?

一个class文件被加载到内存分为三步:装载、链接、初始化。其中链接可细分为:验证、准备、解析。

1. 装载

1.1 什么是装载

装载是指将Java虚拟机查找.class文件并生成字节流,然后根据字节流创建java.lang.Class对象的过程。

这一过程主要完成三件事:

  • 1、ClassLoader通过一个类的全限定名(包名 + 类名)来查找.class文件,并生成二进制字节流:其中class字节码文件的来源不一定是.class文件,也可以是jar包、zip包,甚至是网络的字节流。
  • 2、把.class文件各个部分分别解析(parse)为JVM内部特定的数据结构,并存放在方法区。这点和JSON解析过程有点类似。
  • 3、在内存中创建一个java.lang.Class类型的对象:后面程序在运行过程中所有对该类的访问都通过这个对象,即这个Class类型的对象是提供给外界访问该类的接口。

1.2 加载时机

一个项目编译之后,往往会生成大量的.class文件。当程序运行时,JVM并不会一次性将这些.class文件全部加载到内存中。那JVM什么时候加载某个.class文件?对此,Java虚拟机规范中没有做严格的规定,不同的虚拟机会有不同实现。以下两种情况一般会对class进行装载操作。

  • 隐式装载:在程序运行时,当碰到通过new等方式生成的对象时,系统会隐式调用ClassLoader去装载对应的class到内存中。
  • 显示装载:在编写源代码时,主动调用Class.forName()等方法也会进行class装载操作。

2. 链接

链接分为三步:验证、准备、解析。

2.1 验证

目的是为了确保.class文件的字节流中包含的信息符合当前虚拟机的要求,并且不会危及虚拟机本身的安全。主要包含以下几个方面的检验。

  • 1、文件格式检验:检验字节流是否符合class文件格式的规范,并且能被当前版本的虚拟机处理。
  • 2、元数据检验:对字节码描述的信息进行语义分析,以保证其描述的内容符合Java语言规范的要求。
  • 3、字节码检验:通过数据流和控制流分析,确定程序语义是合法、符合逻辑的。
  • 4、符号引用检验:符号引用检验可以看做是对类自身以外(常量池中的各种符号引用)的信息进行匹配性校验。

实例分析:

下面使用Foo.java来分析验证阶段的几个情况:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class Foo {

public static void main(String[] args) {
new Foo().print();
}

public void print() {
int superCode = super.hashCode();
System.out.println("superCode is " + superCode);

int thisCode = hashCode();
System.out.println("thisCode is " + thisCode);
}

public int hashCode() {
return 111;
}
}

使用javac将Foo.java编译成Foo.class,然后使用16进制编辑器打开.class文件,部分如下:

1
2
3
4
5
6
CA FE BA BE 00 00 00 34 00 36 0A 00 10 00 1C 07
00 1D 0A 00 02 00 1C 0A 00 02 00 1E 0A 00 10 00
1F 09 00 20 00 21 07 00 22 0A 00 07 00 1C 08 00
23 0A 00 07 00 24 0A 00 07 00 25 0A 00 07 00 26
0A 00 27 00 28 0A 00 02 00 1F 08 00 29 07 00 2A
01 00 06 3C 69 6E 69 74 3E 01 00 03 28 29 56 01

正常执行Foo.java,打印如下:

1
2
superCode is 460141958
thisCode is 111

使用16进制编辑器,修改class魔数,将CAFE BABE改成CAFE BABB,重新运行:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
E:\Project\MyStudyDemo\LGDemo\src>java Foo
Error: A JNI error has occurred, please check your installation and try again
Exception in thread "main" java.lang.ClassFormatError: Incompatible magic value 3405691579 in class file Foo
at java.lang.ClassLoader.defineClass1(Native Method)
at java.lang.ClassLoader.defineClass(Unknown Source)
at java.security.SecureClassLoader.defineClass(Unknown Source)
at java.net.URLClassLoader.defineClass(Unknown Source)
at java.net.URLClassLoader.access$100(Unknown Source)
at java.net.URLClassLoader$1.run(Unknown Source)
at java.net.URLClassLoader$1.run(Unknown Source)
at java.security.AccessController.doPrivileged(Native Method)
at java.net.URLClassLoader.findClass(Unknown Source)
at java.lang.ClassLoader.loadClass(Unknown Source)
at sun.misc.Launcher$AppClassLoader.loadClass(Unknown Source)
at java.lang.ClassLoader.loadClass(Unknown Source)
at sun.launcher.LauncherHelper.checkAndLoadMain(Unknown Source)

魔数后面的"0034"为版本号,如果改成"0035"

1
CA FE BA BE 00 00 00 35 00 36 0A 00 10 00 1C 07

运行结果:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
E:\Project\MyStudyDemo\LGDemo\src>java Foo
Error: A JNI error has occurred, please check your installation and try again
Exception in thread "main" java.lang.UnsupportedClassVersionError: Foo has been compiled by a more recent version of the Java Runtime (class file version 53.0), th
is version of the Java Runtime only recognizes class file versions up to 52.0
at java.lang.ClassLoader.defineClass1(Native Method)
at java.lang.ClassLoader.defineClass(Unknown Source)
at java.security.SecureClassLoader.defineClass(Unknown Source)
at java.net.URLClassLoader.defineClass(Unknown Source)
at java.net.URLClassLoader.access$100(Unknown Source)
at java.net.URLClassLoader$1.run(Unknown Source)
at java.net.URLClassLoader$1.run(Unknown Source)
at java.security.AccessController.doPrivileged(Native Method)
at java.net.URLClassLoader.findClass(Unknown Source)
at java.lang.ClassLoader.loadClass(Unknown Source)
at sun.misc.Launcher$AppClassLoader.loadClass(Unknown Source)
at java.lang.ClassLoader.loadClass(Unknown Source)
at sun.launcher.LauncherHelper.checkAndLoadMain(Unknown Source)

版本号"0034"之后的"0036"是常量计数器,表示常量池中有54个常量。这个修改成"0032"

1
CA FE BA BE 00 00 00 35 00 32 0A 00 10 00 1C 07

运行结果:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
E:\Project\MyStudyDemo\LGDemo\src>java Foo
Error: A JNI error has occurred, please check your installation and try again
Exception in thread "main" java.lang.ClassFormatError: Invalid constant pool index 50 in class file Foo
at java.lang.ClassLoader.defineClass1(Native Method)
at java.lang.ClassLoader.defineClass(Unknown Source)
at java.security.SecureClassLoader.defineClass(Unknown Source)
at java.net.URLClassLoader.defineClass(Unknown Source)
at java.net.URLClassLoader.access$100(Unknown Source)
at java.net.URLClassLoader$1.run(Unknown Source)
at java.net.URLClassLoader$1.run(Unknown Source)
at java.security.AccessController.doPrivileged(Native Method)
at java.net.URLClassLoader.findClass(Unknown Source)
at java.lang.ClassLoader.loadClass(Unknown Source)
at sun.misc.Launcher$AppClassLoader.loadClass(Unknown Source)
at java.lang.ClassLoader.loadClass(Unknown Source)
at sun.launcher.LauncherHelper.checkAndLoadMain(Unknown Source)

虽然JVM会检查各种对class字节码文件的篡改行为,但是依然无法保证class文件的安全性。比如在Foo.java中的print()方法中,分别打印出父类的自身类的hashCode值,分别是460141958和111。我们可以在class字节码的基础上篡改,将父类的hashCode返回111。

通过javap -v Foo查看Foo.class中常量池的具体信息(部分):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
Constant pool:
#1 = Methodref #16.#28 // java/lang/Object."<init>":()V
#2 = Class #29 // Foo
#3 = Methodref #2.#28 // Foo."<init>":()V
#4 = Methodref #2.#30 // Foo.print:()V
#5 = Methodref #16.#31 // java/lang/Object.hashCode:()I
#6 = Fieldref #32.#33 // java/lang/System.out:Ljava/io/PrintStream;
#7 = Class #34 // java/lang/StringBuilder
#8 = Methodref #7.#28 // java/lang/StringBuilder."<init>":()V
#9 = String #35 // superCode is
#10 = Methodref #7.#36 // java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
#11 = Methodref #7.#37 // java/lang/StringBuilder.append:(I)Ljava/lang/StringBuilder;
#12 = Methodref #7.#38 // java/lang/StringBuilder.toString:()Ljava/lang/String;
#13 = Methodref #39.#40 // java/io/PrintStream.println:(Ljava/lang/String;)V
#14 = Methodref #2.#31 // Foo.hashCode:()I
#15 = String #41 // thisCode is
#16 = Class #42 // java/lang/Object

#5处指向了父类ObjecthashCode方法,#14处指向了FoohashCode方法。第03节中,已经了解到CONSTANT_Methodref_info结构如下:

1
2
3
4
5
CONSTANT_Methodref_info{
u1 tag = 10;
u2 class_index; // 指向此方法的所属类
u2 name_type_index; // 指向此方法名称和类型
}

其中class_index就是指向方法的所属类,示例中为16,转化为16进制为0X10,因此只需要使用16进制编辑器将指向Objectclass_index改为执行Fooclass_index即可。具体修改如下:

"0X10"改成"0X02",重新运行:

1
2
3
E:\Project\MyStudyDemo\LGDemo\src>java Foo
superCode is 111
thisCode is 111

可以看出,虽然在Java源文件中调用了super.hashCode()方法,但是经过篡改之后,Foo.class文件成功通过了JVM校验,并成功执行最终打印。

注意,上面的实例说明,即使没有Java源文件,某种程度上,也可以对编译之后的class字节码进行篡改。这也是为什么在项目中使用混淆,甚至使用一些第三方加固软件,来保证编写的代码的安全性。

2.2 准备

目的是为类中的静态变量分配内存,并为其设置“0值”。比如:

1
public static int value = 100;

在准备阶段,JVM会为value分配内存,并将其设置为0。而真正的值100是在初始化阶段设置的。并且此阶段进行内存分配的仅包括类变量,而不包括实例变量(实例变量将会在对象初始化时随对象一起分配在Java堆中)。

有一种情况比较特殊——静态常量,比如:

1
public static final int value = 100;

以上代码会在准备阶段为value分配内存,并设置为100。

Java中基本类型的默认“0值”如下:

  • 基本类型的默认值为0;
  • 引用类型的默认值为null。

2.3 解析

这一阶段的任务是把常量池中的符号引用转换为直接引用,也就是具体的内存地址。在这一阶段,JVM会将常量池中的类、接口名、字段名、方法名等转换为具体的内存地址。

比如上面Foo.java中编译之后main方法的字节码如下:

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
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
Constant pool:
#1 = Methodref #16.#28 // java/lang/Object."<init>":()V
#2 = Class #29 // Foo
#3 = Methodref #2.#28 // Foo."<init>":()V
#4 = Methodref #2.#30 // Foo.print:()V
#5 = Methodref #2.#31 // Foo.hashCode:()I
#6 = Fieldref #32.#33 // java/lang/System.out:Ljava/io/PrintStream;
#7 = Class #34 // java/lang/StringBuilder
#8 = Methodref #7.#28 // java/lang/StringBuilder."<init>":()V
#9 = String #35 // superCode is
#10 = Methodref #7.#36 // java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
#11 = Methodref #7.#37 // java/lang/StringBuilder.append:(I)Ljava/lang/StringBuilder;
#12 = Methodref #7.#38 // java/lang/StringBuilder.toString:()Ljava/lang/String;
#13 = Methodref #39.#40 // java/io/PrintStream.println:(Ljava/lang/String;)V
#14 = Methodref #2.#31 // Foo.hashCode:()I
#15 = String #41 // thisCode is
#16 = Class #42 // java/lang/Object
#17 = Utf8 <init>
#18 = Utf8 ()V
#19 = Utf8 Code
#20 = Utf8 LineNumberTable
#21 = Utf8 main
#22 = Utf8 ([Ljava/lang/String;)V
#23 = Utf8 print
#24 = Utf8 hashCode
#25 = Utf8 ()I
#26 = Utf8 SourceFile
#27 = Utf8 Foo.java
#28 = NameAndType #17:#18 // "<init>":()V
#29 = Utf8 Foo
#30 = NameAndType #23:#18 // print:()V
#31 = NameAndType #24:#25 // hashCode:()I
#32 = Class #43 // java/lang/System
#33 = NameAndType #44:#45 // out:Ljava/io/PrintStream;
#34 = Utf8 java/lang/StringBuilder
#35 = Utf8 superCode is
#36 = NameAndType #46:#47 // append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
#37 = NameAndType #46:#48 // append:(I)Ljava/lang/StringBuilder;
#38 = NameAndType #49:#50 // toString:()Ljava/lang/String;
#39 = Class #51 // java/io/PrintStream
#40 = NameAndType #52:#53 // println:(Ljava/lang/String;)V
#41 = Utf8 thisCode is
#42 = Utf8 java/lang/Object
#43 = Utf8 java/lang/System
#44 = Utf8 out
#45 = Utf8 Ljava/io/PrintStream;
#46 = Utf8 append
#47 = Utf8 (Ljava/lang/String;)Ljava/lang/StringBuilder;
#48 = Utf8 (I)Ljava/lang/StringBuilder;
#49 = Utf8 toString
#50 = Utf8 ()Ljava/lang/String;
#51 = Utf8 java/io/PrintStream
#52 = Utf8 println
#53 = Utf8 (Ljava/lang/String;)V
{
public Foo();
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 1: 0

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: new #2 // class Foo
3: dup
4: invokespecial #3 // Method "<init>":()V
7: invokevirtual #4 // Method print:()V
10: return
LineNumberTable:
line 4: 0
line 5: 10

main方法中通过invokespecial指令调用print方法,Foo.print:()V就是一个符号引用,当main方法执行到此处时,会将符号引用 Foo.print:()V解析成直接引用,可以将直接引用理解为方法真正的内存地址。

对于符号引用和直接引用,可以与微信聊天类比,在微信好友列表中,保存的是好友的名称或别名(就是符号引用),当真正给某个好友发送消息时,计算机(JVM)会根据好友的名称找到对象计算机的IP地址(直接引用)并将消息发送给这一地址。

3. 初始化

这一阶段执行类构造器<clinit>方法的过程,并真正初始化类变量。比如:

1
public static int value = 100;

在准备阶段value被分配内存,并设置为0,在初始化阶段value就会被设置为100。

3.1 初始化的时机

对于装载阶段,JVM并没有规范何时具体执行。但是对于初始化,JVM规范中严格规定了class初始化的时机,主要有以下几种情况会触发class的初始化:

  • 1、虚拟机启动时,初始化包含main方法的主类;
  • 2、遇到new指令创建对象实例时,如果目标对象类没有被初始化则进行初始化操作;
  • 3、遇到访问静态方法或静态字段的指令时,如果目标对象类没有被初始化则进行初始化操作;
  • 4、子类的初始化过程如果发现其父类没有进行初始化,则需要先触发其父类的初始化;
  • 5、使用反射API进行反射调用时,如果类没有进行初始化则需要先触发其初始化;
  • 6、第一次调用java.lang.invoke.MethodHandle实例时,需要初始化MethodHandle指向方法所在的类。

3.2 初始化类变量

在初始化阶段,只会初始化与类相关的静态赋值语句和静态语句,也就是有static关键字修饰的信息,而没有static修饰的语句块在实例化对象的时候才进行初始化。

如下代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
public class ClassInit {
public static int value = 1;

// 静态语句块在初始化阶段执行
static {
System.out.println("ClassInit static block!");
}

// 非静态语句块只在创建对象实例时被执行
{
System.out.println("ClassInit non-static block!");
}
}

然后在ClassInitTest.java中访问ClassInitvalue值:

1
2
3
4
5
public class ClassInitTest {
public static void main(String[] args) {
ClassInit.value = 2;
}
}

执行代码,打印:

1
ClassInit static block!

可以看出,非静态代码块没有被执行。如果将ClassInitTest.java修改成:

1
2
3
4
5
6
public class ClassInitTest {
public static void main(String[] args) {
ClassInit.value = 2;
ClassInit ci = new ClassInit();
}
}

再次执行,就会执行非静态代码块,打印:

1
2
ClassInit static block!
ClassInit non-static block!

3.3 被动引用

上述的6种情况在JVM中被称为主动引用,除此6种情况之外所有引用类的方式都被称为被动引用。被动引用并不会触发class的初始化。

最典型的就是子类调用父类的静态变量,比如:

1
2
3
4
5
6
7
8
9
10
11
12
13
class Parent {
public static int value = 1;

static {
System.out.println("this is Parent!");
}
}

class Child extends Parent {
static {
System.out.println("this is Child!");
}
}

Child继承了Parent,如果直接使用Child来访问Parentvalue值,则不会初始化Child类,如下:

1
2
3
4
5
class NonInitTest {
public static void main(String[] args) {
Child.value = 2;
}
}

打印:

1
this is Parent!

可以看出,Child中的静态代码没有执行。也就是说JVM没有对Child进行初始化操作。

对于静态字段,只有直接定义这个字段的类才会被初始化,因此通过子类Child来引用父类Parent中定义的静态字段,只会触发Parent额初始化。至于是否要触发子类的加载和验证,在虚拟机规范中没有明确规定,可以通过XX:-TraceClassLoading参数来查看,比如使用如下命令再次执行NonInitTest:(先javac NonInitTest.java编译)

1
java XX:-TraceClassLoading NonInitTest

打印(部分):

1
2
3
[Loaded Parent from file:/E:/Project/MyStudyDemo/LGDemo/src/]
[Loaded Child from file:/E:/Project/MyStudyDemo/LGDemo/src/]
this is Parent!

可以看到,虽然只有Parent被初始化,但是ParentChild都经过了装载和验证阶段,并被加载到了内存中。

3.4 class初始化和对象的创建顺序

关于class的初始化还有一点经常被提及,就是对象的初始化顺序。当在代码中使用new创建一个类的实例对象时,类中的静态代码块、费静态代码块、构造函数之间的执行顺序是怎样的:

如下代码:

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 InitOrder {
public static void main(String[] args) {
Parent p = new Child();
System.out.println("-----------------------");
p = new Child();
}

static class Child extends Parent {
static {
System.out.println("Child static block!");
}

{
System.out.println("Child non-static block!");
}

public Child() {
System.out.println("Child constructor!");
}
}

static class Parent {
static {
System.out.println("Parent static block!");
}

{
System.out.println("Parent non-static block!");
}

public Parent() {
System.out.println("Parent constructor!");
}
}
}

打印:

1
2
3
4
5
6
7
8
9
10
11
Parent static block!
Child static block!
Parent non-static block!
Parent constructor!
Child non-static block!
Child constructor!
-----------------------
Parent non-static block!
Parent constructor!
Child non-static block!
Child constructor!

对象初始化顺序:
静态变量/静态代码块 -> 普通代码块 -> 构造函数

  • 1、父类静态变量和静态代码块;
  • 2、子类静态变量和静态代码块;
  • 3、父类普通成员变量和普通代码块;
  • 4、父类构造函数;
  • 5、子类普通成员变量和普通代码块;
  • 6、子类构造函数;

更多参考链接

4. 总结

  • 1、装载:查找字节流,并根据此字节流创建类的过程。装载过程成功的标志就是在方法区中成功创建类所对应的Class对象。
  • 2、链接:验证创建的类,并将其解析到JVM中使之能被JVM执行。
  • 3、初始化:将标记为static的字段进行赋值,并且执行static标记的代码语句。
  • Copyrights © 2019-2020 Tyler Liu

请我喝杯咖啡吧~

支付宝
微信