JVM 类加载器子系统

类加载器以及类的加载过程

1. 加载阶段

   • 引导类加载器
   • 扩展类加载器
   • 系统类加载器

2. 链接阶段

   • 验证
   • 准备
   • 解析

3. 初始化阶段

   初始化

加载阶段

加载过程(Loading)

1. 通过一个类的全限定名获取定义此类的二进制字节流
2. 将这个字节流所代表的静态储存结构转化为方法区的运行时数据结构
3. 在内存中生成一个代表这个类的java.lang.Class对象，作为方法区这个类的各种数据的访问接口

链接阶段(Linking)

验证(Verify)

• 目的在于确保Class文件的字节流包含信息符合当前虚拟机要求，保证被加载的正确性，不会危害虚拟机自身的安全
• 主要有四种验证：文件格式验证、元数据验证、字节码验证、符号引用验证

准备(Prepare)

• 为类变量分配内存并设置该类变量的默认初始值即零值
• 这里不包含用final修饰的static，因为final在编译的时候就会分配了，准备阶段回显示初始化
• 这里不会为实例变量分配初始化，类变量会分配在方法区中，而实例变量是会随着对象一起分配到Java堆中

解析(Resolve)

• 将常量池内的符号引用转化为直接引用的过程
• 事实上，解析操作往往会伴随着JVM在执行完初始化之后再执行
• 符号引用就是一组符号来描述所引用的目标。直接引用就是直接指向目标的指针、相对偏移量或一个间接定位到目标的句柄
• 解析动作主要针对类或接口、字段、类方法、接口方法、方法类型等。对应常量池中的CONSTANT_Class_info、CONSTANT_Fieldref_info、CONSTANT_Methodref_info等

初始化(Initialization)

• 初始化阶段就是执行类构造器方法()的过程

• 此方法不需要定义，是javac编译器自动收集类中的所有类变量的赋值动作和静态代码块中的语句合并起来

• 构造方法中指令按语句在源文件中出现的顺序执行

• ()不同于类的构造器（构造器是虚拟机视角下的()）

• 若该类有父类，JVM会保证子类的()执行前，父类的()已经执行完毕

• 虚拟机必须保证一个类的()方法在多线程情况下被同步加锁

示例1

• 此方法不需要定义，是javac编译器自动收集类中的所有类变量的赋值动作和静态代码块中的语句合并起来
• 构造方法中指令按语句在源文件中出现的顺序执行

public class ClassClinitTest {
  private static int num = 1;
  
  static {
   	num = 2;
    number = 20;
    System.out.println(num);
    // System.out.println(number); 报错 非法的前向引用  
  }
  
  private static int number = 10; //linking的prepare: number = 0 --> initial: 20 --> 10
  
  public static void main(String[] args) {
    System.out.println(ClassClinitTest.num);//2
    System.out.println(ClassClinitTest.number);//10
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

的指令

 0 iconst_1
 1 putstatic #3 
 4 iconst_2
 5 putstatic #3 
 8 bipush 20
10 putstatic #5 
13 getstatic #2 
16 getstatic #3 
19 invokevirtual #4 
22 bipush 10
24 putstatic #5 
27 return
1
2
3
4
5
6
7
8
9
10
11
12

注意：

如果没有静态变量就不会有方法

方法是构造器函数（任何一个类声明后，至少会存在一个构造器）

示例2

()不同于类的构造器（构造器是虚拟机视角下的()）

package com.ambitfly.java;

public class InitTest {
    // 任何一个类声明后，至少会存在一个构造器
    private int a = 1;
    private static int c = 3;
    public static void main(String[] args) {
        int b = 2;
    }
}
1
2
3
4
5
6
7
8
9
10

()方法指令

0 aload_0
1 invokespecial #1 >
4 aload_0
5 iconst_1
6 putfield #2 
9 return
1
2
3
4
5
6

自定义构造器

package com.ambitfly.java;

public class InitTest {
    // 任何一个类声明后，至少会存在一个构造器
    private int a = 1;
    private static int c = 3;

    public InitTest(){
        a = 4;
    }
    public static void main(String[] args) {
        int b = 2;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

方法指令

 0 aload_0
 1 invokespecial #1 >
 4 aload_0
 5 iconst_1
 6 putfield #2 
 9 aload_0
10 iconst_4
11 putfield #2 
14 return
1
2
3
4
5
6
7
8
9

实例3

若该类有父类，JVM会保证子类的()执行前，父类的()已经执行完毕

public class ClinitTest {
    static class Father {
        public static int A = 1;
        static {
            A = 2;
        }
        static class Son extends Father{
            public static int B = A;
        }

        public static void main(String[] args) {
            System.out.println(Son.B);//2
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

()指令

0 getstatic #2 
3 putstatic #3 
6 return
1
2
3

实例4

虚拟机必须保证一个类的()方法在多线程情况下被同步加锁

package com.ambitfly.java;

public class DeadThreadTest {
    public static void main(String[] args) {
        Runnable r = () -> {
            System.out.println(Thread.currentThread().getName() + "开始");
            DeadThread dead = new DeadThread();
            System.out.println(Thread.currentThread().getName() + "结束");
        };

        Thread t1 = new Thread(r, "线程1");
        Thread t2 = new Thread(r, "线程2");

        t1.start();
        t2.start();
    }
}

class DeadThread {
    static {
        if(true){
            System.out.println(Thread.currentThread().getName() + "初始化当前类");
            while (true){

            }
        }
    }
}


/**
运行结果：
线程1开始
线程2开始
线程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
34
35
36