JVM(三):字节码与类加载


字节码指令

javap工具

Oracle提供了class文件反编译工具:javap,使用:javap -v Hello.class,即可反编译Hello.class文件。

效果如下:

Classfile /D:/IDEA/Workspace/JVM/out/production/JVM/Hello.class
  Last modified 2022811; size 519 bytes
  SHA-256 checksum 8045a3a5ec29528b945e8ad71cc0b6274ef2bb7a5513aa2c2473446f744189cf
  Compiled from "Hello.java"
public class Hello
  minor version: 0
  major version: 52
  flags: (0x0021) ACC_PUBLIC, ACC_SUPER
  this_class: #5                          // Hello
  super_class: #6                         // java/lang/Object
  interfaces: 0, fields: 0, methods: 2, attributes: 1
Constant pool:
   #1 = Methodref          #6.#20         // java/lang/Object."<init>":()V
   #2 = Fieldref           #21.#22        // java/lang/System.out:Ljava/io/PrintStream;
   #3 = String             #23            // Hello World!
   #4 = Methodref          #24.#25        // java/io/PrintStream.println:(Ljava/lang/String;)V
   #5 = Class              #26            // Hello
   #6 = Class              #27            // java/lang/Object
   #7 = Utf8               <init>
   #8 = Utf8               ()V
   #9 = Utf8               Code
  #10 = Utf8               LineNumberTable
  #11 = Utf8               LocalVariableTable
  #12 = Utf8               this
  #13 = Utf8               LHello;
  #14 = Utf8               main
  #15 = Utf8               ([Ljava/lang/String;)V
  #16 = Utf8               args
  #17 = Utf8               [Ljava/lang/String;
  #18 = Utf8               SourceFile
  #19 = Utf8               Hello.java
  #20 = NameAndType        #7:#8          // "<init>":()V
  #21 = Class              #28            // java/lang/System
  #22 = NameAndType        #29:#30        // out:Ljava/io/PrintStream;
  #23 = Utf8               Hello World!
  #24 = Class              #31            // java/io/PrintStream
  #25 = NameAndType        #32:#33        // println:(Ljava/lang/String;)V
  #26 = Utf8               Hello
  #27 = Utf8               java/lang/Object
  #28 = Utf8               java/lang/System
  #29 = Utf8               out
  #30 = Utf8               Ljava/io/PrintStream;
  #31 = Utf8               java/io/PrintStream
  #32 = Utf8               println
  #33 = Utf8               (Ljava/lang/String;)V
{
  public Hello();
    descriptor: ()V
    flags: (0x0001) 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
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       5     0  this   LHello;

        line 4: 8
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       9     0  args   [Ljava/lang/String;
}
SourceFile: "Hello.java"

方法执行流程

对于以下代码:

public class Demo3_1 {    
	public static void main(String[] args) {        
		int a = 10;    
         //Short.MAX_VALUE=32767
		int b = Short.MAX_VALUE + 1;        
		int c = a + b;        
		System.out.println(c);   
    } 
}

其代码字节码如下:

Code:
      stack=2, locals=4, args_size=1
         0: bipush        10
         2: istore_1
         3: ldc           #3                  // int 32768
         5: istore_2
         6: iload_1
         7: iload_2
         8: iadd
         9: istore_3
        10: getstatic     #4                  // Field java/lang/System.out:Ljava/io/PrintStream;
        13: iload_3
        14: invokevirtual #5                  // Method java/io/PrintStream.println:(I)V
        17: return
      LineNumberTable:
        line 4: 0
        line 5: 3
        line 6: 6
        line 7: 10
        line 8: 17
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      18     0  args   [Ljava/lang/String;
            3      15     1     a   I
            6      12     2     b   I
           10       8     3     c   I

其方法执行过程如下:

常量池载入运行时常量池

常量池载入运行时常量池

方法字节码载入方法区

方法字节码载入方法区

main 线程开始运行,分配栈帧内存

(stack=2,locals=4) 对应操作数栈有2个空间(每个空间4个字节),局部变量表中有4个槽位

image-20220811084016726

执行引擎开始执行字节码

  1. bipush 10

    • 将一个 byte 压入操作数栈(其长度会补齐 4 个字节),类似的指令还有
      • sipush 将一个 short 压入操作数栈(其长度会补齐 4 个字节)
      • ldc 将一个 int 压入操作数栈
      • ldc2_w 将一个 long 压入操作数栈(分两次压入,因为 long 是 8 个字节)
      • 这里小的数字都是和字节码指令存在一起,超过 short 范围的数字存入了常量池

    image-20220811084458739

  2. istore 1

    • 将操作数栈栈顶元素弹出,放入局部变量表的slot 1中,对应a = 10

    image-20220811084953810

    image-20220811085013907

  3. ldc #3

    • 读取运行时常量池中#3,即32768(超过short最大值范围的数会被放到运行时常量池中),将其加载到操作数栈中;

    • 注意:Short.MAX_VALUE 是 32767,所以 32768 = Short.MAX_VALUE + 1 实际是在编译期间计算好的

    image-20220811085143043

  4. istore 2

    • 将操作数栈中的元素弹出,放到局部变量表的2号位置

    image-20220811085206902

    image-20220811085336914

  5. iload1 iload2

    • 因为只能在操作数栈中执行运算操作,所以这一步要将局部变量表中1号位置和2号位置的元素放入操作数栈中
    iload1 iload2
  6. iadd

    • 将操作数栈中的两个元素弹出栈并相加,结果在压入操作数栈中

    image-20220811085700108

    image-20220811085715975

  7. istore 3

    • 将操作数栈中的元素弹出,放入局部变量表的3号位置

    image-20220811085845173

    image-20220811085904999

  8. getstatic #4

    • 在运行时常量池中找到#4,发现是一个对象,在堆内存中找到该对象,并将其引用放入操作数栈中

    image-20220811085942320

    image-20220811085959837

  9. iload 3

    • 将局部变量表中3号位置的元素压入操作数栈中

    image-20220811090031656

    image-20220811090041903

  10. invokevirtual 5

    • 找到常量池 #5 项
    • 定位到方法区 java/io/PrintStream.println:(I)V 方法
    • 生成新的栈帧(分配 locals、stack等)
    • 传递参数,执行新栈帧中的字节码

    image-20220811090154439

    • 执行完毕,弹出栈帧
    • 清除 main 操作数栈内容

    image-20220811090304742

  11. return

    • 完成 main 方法调用,弹出 main 栈帧
    • 程序结束

字节码分析i++与++i

对于以下代码,进行分析:

/**
* 从字节码角度分析 a++ 相关题目
*/
public class test {
  public static void main(String[] args) {
    int a = 10;
    int b = a++ + ++a + a--;
    System.out.println(a);
    System.out.println(b);
 }
}

其字节码为:

public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: (0x0009) ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=3, args_size=1
         0: bipush        10
         2: istore_1
         3: iload_1
         4: iinc          1, 1
         7: iinc          1, 1
        10: iload_1
        11: iadd
        12: iload_1
        13: iinc          1, -1
        16: iadd
        17: istore_2
        18: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
        21: iload_1
        22: invokevirtual #3                  // Method java/io/PrintStream.println:(I)V
        25: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
        28: iload_2
        29: invokevirtual #3                  // Method java/io/PrintStream.println:(I)V
        32: return
      LineNumberTable:
        line 6: 0
        line 7: 3
        line 8: 18
        line 9: 25
        line 10: 32
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      33     0  args   [Ljava/lang/String;
            3      30     1     a   I
           18      15     2     b   I

分析:

  • iinc指令是直接在局部变量 slot 上进行运算
  • a++是先执行iload指令,再执行iinc指令自增;++a反之。

过程:

image-20220811102320428

image-20220811102415989

image-20220811102527056

image-20220811102604591

image-20220811102653406

image-20220811102740772

image-20220811102827477

image-20220811102920254

image-20220811103003529

image-20220811103105195

image-20220811103136834

条件判断指令

指令 助记符 含义
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 用来进行跳转到指定行号的字节码。

举例:

//代码:
public class test {
  public static void main(String[] args) {
    int a = 0;
    if(a == 0) {
      a = 10;
   } else {
      a = 20;
   }
 }
}

//字节码:
0: iconst_0
1: istore_1
2: iload_1   
3: ifne     12
6: bipush    10
8: istore_1
9: goto     15
12: bipush    20
14: istore_1
15: return

循环控制指令

  1. while循环

    //代码:
    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: return
  2. do-while循环

    //代码
    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: return
  3. for循环

    //代码
    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
  4. 练习:判断以下代码输出

    public 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
    	}
    }

    字节码为:

    Code:
         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 :
//代码:
public class Demo3 {
	static int i = 10;

	static {
		i = 20;
	}

	static {
		i = 30;
	}

	public static void main(String[] args) {
		System.out.println(i); //结果为30
	}
}

//字节码:
stack=1, locals=0, args_size=0
         0: bipush        10
         2: putstatic     #3                  // Field i:I
         5: bipush        20
         7: putstatic     #3                  // Field i:I
        10: bipush        30
        12: putstatic     #3                  // Field i:I
        15: return

init()V

  • 编译器会按从上至下的顺序,收集所有 {} 代码块和成员变量赋值的代码,形成新的构造方法,但原始构造方法内的代码总是在后
//代码:
public class test {
    private String a = "s1";

    {
        b = 20;
    }

    private int b = 10;

    {
        a = "s2";
    }

    public test(String a, int b) {
        this.a = a;
        this.b = b;
    }

    public static void main(String[] args) {
        test d = new test("s3", 30);
        System.out.println(d.a);  //s3
        System.out.println(d.b);  //30
    }
}
//字节码:
 Code:
      stack=2, locals=3, args_size=3
         0: aload_0
         1: invokespecial #1    // super.<init>()V                 
         4: aload_0
         5: ldc           #2    // <- "s1"                
         7: putfield      #3    // -> this.a              
        10: aload_0
        11: bipush        20    // <- 20
        13: putfield      #4    // -> this.b        
        16: aload_0
        17: bipush        10    // <- 10
        19: putfield      #4    // -> this.b            
        22: aload_0
        23: ldc           #5    // <- "s2"                
        25: putfield      #3    // -> this.a             
        28: aload_0             // ------------------------------
        29: aload_1             // <- slot 1(a) "s3"            |  
        30: putfield      #3    // -> this.a                    | 原始构造方法代码       
        33: aload_0             //                              |
        34: iload_2             // <- slot 2(b) 30              |
        35: putfield      #4    // -> this.b --------------------                  
        38: return
      LineNumberTable:
        line 15: 0
        line 3: 4
        line 6: 10
        line 9: 16
        line 12: 22
        line 16: 28
        line 17: 33
        line 18: 38
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      39     0  this   Ltest;
            0      39     1     a   Ljava/lang/String;
            0      39     2     b   I

方法调用

规则:

  • new是创建对象,给对象分配堆内存,执行成功会将对象引用压入操作数栈;
  • dup 是复制操作数栈栈顶的内容,本例即为对象引用,为什么需要额外复制引用呢,一个是要配合 invokespecial 调用该对象的构造方法 "<init>":()V(会消耗掉栈顶一个引用),另一个要配合 astore_1 赋值给局部变量;
  • 最终方法(final),私有方法(private),构造方法都是由 invokespecial 指令来调用,属于静态绑定;
  • 普通成员方法是由 invokevirtual 调用,属于动态绑定,即支持多态;
  • 成员方法与静态方法调用的另一个区别是,执行方法前是否需要对象引用,即观察是否需要执行aload_1
  • 还有一个执行 invokespecial 的情况是通过 super 调用父类方法。

代码示例:

//代码;
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

  1. 规则:

    • 可以看到多出来一个 Exception table 的结构,[from, to) 是左闭右开(也就是检测2~4行)的检测范围,一旦这个范围内的字节码执行出现异常,则通过 type 匹配异常类型,如果一致,进入 target 所指示行号;
    • 8行的字节码指令 astore_2 是将异常对象引用存入局部变量表的2号位置(为e)。
  2. 代码示例:

    //代码
    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

  1. 规则:

    • 异常出现时,只能进入 Exception table 中一个分支,所以局部变量表 slot 2 位置被共用
  2. 代码示例:

    //代码:
    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

  1. 规则:

    • finally 中的代码会被复制 n 份,分别放入 try 流程,catch 流程以及 catch剩余的异常类型流程;
    • 虽然从字节码指令看来,每个块中都有finally块,但是finally块中的代码只会被执行一次
  2. 代码示例:

    //代码:
    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. 代码示例:

    //代码:
    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
  2. 规则:

    • 由于 finally 中的 ireturn 被插入了所有可能的流程,因此返回结果以finally的为准;
    • 字节码第二行的作用是暂存try中的返回值;
    • 跟上例中的 finally 相比,发现没有 athrow 了,这告诉我们:如果在 finally 中出现了 return,会吞掉异常(如下段代码),所以不要在finally中进行返回操作
    //该段代码本应该抛出异常,但由于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. 代码示例:

    //代码:
    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
  2. 规则:

    • finally中的赋值语句不会影响try中的return:try中将要返回的值会被暂存在临时变量表中,即使finally中改变了返回值,也不会影响最终返回的值。

Synchronized

  1. 代码示例:

    //代码:
    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
  2. 规则:

    • 由字节码可知,即使出异常,也会正确的进行解锁操作。

编译期处理

编译器处理即语法糖,是指 java 编译器把 *.java 源码编译为 *.class 字节码的过程中,自动生成转换的一些代码,主要是为了减轻程序员的负担。

以下代码的分析,借助了 javap 工具,idea 的反编译功能,idea 插件 jclasslib 等工具。另外,编译器转换的结果直接就是 class 字节码,只是为了便于阅读,给出了 几乎等价 的 java 源码方式,并不是编译器还会转换出中间的 java 源码。

默认构造函数

//代码:
public class Candy1 {
}

//编译器优化
public class Candy1 {
   //这个无参构造器是java编译器帮我们加上的
   public Candy1() {
      //即调用父类 Object 的无参构造方法,即调用 java/lang/Object." <init>":()V
      super();
   }
}

自动拆装箱

//代码:
public class Demo2 {
   public static void main(String[] args) {
      Integer x = 1;
      int y = x;
   }
}
//优化:
/*
  在JDK 5以后,它们的转换可以在编译期自动完成
*/
public class Demo2 {
   public static void main(String[] args) {
      //基本类型赋值给包装类型,称为装箱
      Integer x = Integer.valueOf(1);
      //包装类型赋值给基本类型,称谓拆箱
      int y = x.intValue();
   }
}

泛型集合取值

泛型是在 JDK 5 开始加入的特性,但 java 在编译泛型代码后会执行 泛型擦除 的动作,即泛型信息在编译为字节码之后就丢失了,实际的类型都当做了 Object 类型来处理,如下代码:

//代码:
public class Demo3 {
   public static void main(String[] args) {
      List<Integer> list = new ArrayList<>();
      list.add(10);
      Integer x = list.get(0);
   }
}

//字节码:
Code:
    stack=2, locals=3, args_size=1
       0: new           #2                  // class java/util/ArrayList
       3: dup
       4: invokespecial #3                  // Method java/util/ArrayList."<init>":()V
       7: astore_1
       8: aload_1
       9: bipush        10
      11: invokestatic  #4                  // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
      //进行泛型擦除,实际调用的是add(Objcet o)
      14: invokeinterface #5,  2            // InterfaceMethod java/util/List.add:(Ljava/lang/Object;)Z

      19: pop
      20: aload_1
      21: iconst_0
      //也进行了泛型擦除,实际调用的是get(Object o)   
      22: invokeinterface #6,  2            // InterfaceMethod java/util/List.get:(I)Ljava/lang/Object;
	 //这里进行了类型转换,将Object转换成了Integer
      27: checkcast     #7                  // class java/lang/Integer
      30: astore_2
      31: return

由以上字节码可知:

  • 在调用get函数取值时,会进行类型转换:Integer x = (Integer) list.get(0);
  • 若要将返回结果赋值给一个int类型的变量,则还有自动拆箱的操作:int x = (Integer) list.get(0).intValue();

可变参数

由赋值语句可知:可变参数String… args是一个String[] args,所以编译器会在编译期间进行转换。

//代码:
public class Demo4 {
   public static void foo(String... args) {
      //将args赋值给arr,可以看出String...实际就是String[] 
      String[] arr = args;
      System.out.println(arr.length);
   }

   public static void main(String[] args) {
      foo("hello", "world");
   }
}

//优化:

/*
  注意,如果调用的是foo(),即未传递参数时,等价代码为foo(new String[]{}),创建了一个空数组,而不是直接传递的null
*/
public class Demo4 {
   public Demo4 {}
  
   public static void foo(String[] args) {
      String[] arr = args;
      System.out.println(arr.length);
   }

   public static void main(String[] args) {
      foo(new String[]{"hello", "world"});
   }
}

foreach

数组进行foreach遍历

//代码:
public class Demo5 {
	public static void main(String[] args) {
        //注:数组赋初值的简化写法也是一种语法糖
		int[] arr = {1, 2, 3, 4, 5};
		for(int x : arr) {
			System.out.println(x);
		}
	}
}

//优化:
public class Demo5 {
    public Demo5 {}

	public static void main(String[] args) {
        //数组初始化语法糖
		int[] arr = new int[]{1, 2, 3, 4, 5};
		for(int i=0; i<arr.length; ++i) {
			int x = arr[i];
			System.out.println(x);
		}
	}
}

集合进行foreach遍历

集合要使用foreach,需要该集合类实现了Iterable接口,因为集合的遍历需要用到迭代器Iterator

//代码:
public class Demo5 {
   public static void main(String[] args) {
      List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
      for (Integer x : list) {
         System.out.println(x);
      }
   }
}

//优化:
public class Demo5 {
    public Demo5 {}
    
   public static void main(String[] args) {
      List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
      //获得该集合的迭代器
      Iterator<Integer> iterator = list.iterator();
      while(iterator.hasNext()) {
         Integer x = iterator.next();
         System.out.println(x);
      }
   }
}

switch

switch字符串

  1. 运行过程:

    在编译期间,单个的switch被分为了两个:

    • 第一个用来匹配字符串,并给x赋值
      • 字符串的匹配用到了字符串的hashCode,还用到了equals方法
      • 使用hashCode是为了提高比较效率,使用equals是防止有hashCode冲突(如BM和C.)
    • 第二个用来根据x的值来决定输出语句
  2. 代码:

    //代码:
    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枚举

  1. 运行过程:

    • 定义一个合成类(仅 jvm 使用,对我们不可见)用来映射枚举的 ordinal 与数组元素的关系;
    • 枚举的 ordinal 表示枚举对象的序号,从 0 开始,即 MALE 的 ordinal()=0,FEMALE 的 ordinal()=1;
    • case再通过对象在数组中的位置判断输出。
  2. 代码:

    //代码:
    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;
    }

枚举类

//代码:
enum SEX {
   MALE, FEMALE;
}

//优化:
public final class Sex extends Enum<Sex> {   
   //对应枚举类中的元素
   public static final Sex MALE;    
   public static final Sex FEMALE;    
   private static final Sex[] $VALUES;
   
    static {       
    	//调用构造函数,传入枚举元素的值及ordinal
    	MALE = new Sex("MALE", 0);    
        FEMALE = new Sex("FEMALE", 1);   
        $VALUES = new Sex[]{MALE, FEMALE}; 
   }
 	
   //调用父类中的方法
    private Sex(String name, int ordinal) {     
        super(name, ordinal);    
    }
   
    public static Sex[] values() {  
        return $VALUES.clone();  
    }
    public static Sex valueOf(String name) { 
        return Enum.valueOf(Sex.class, name);  
    } 
}

匿名内部类

  1. 常规:

    //代码;
    public class Demo8 {
       public static void main(String[] args) {
          Runnable runnable = new Runnable() {
             @Override
             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() {}
    
       @Override
       public void run() {
          System.out.println("running...");
       }
    }
  2. 若匿名内部类中引用了局部变量

    //代码:
    public class Demo8 {
       public static void main(String[] args) {
          int x = 1;
          Runnable runnable = new Runnable() {
             @Override
             public void run() {
                System.out.println(x);
             }
          };
       }
    }
    
    //优化:
    public class Demo8 {
       public static void main(String[] args) {
          int x = 1;
          Runnable runnable = new Runnable() {
             @Override
             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;
       }
    
       @Override
       public void run() {
          System.out.println(val$x);
       }
    }

类加载机制

类加载阶段

加载

  1. 在加载阶段,需要完成以下事情:
    • 通过一个类的全限定名来获取定义此类的二进制字节流。
    • 将这个字节流所代表的静态存储结构转化为方法区的运行时数据结构。
    • 在内存中生成一个代表这个类的java.lang.Class对象,作为方法区这个类的各种数据的访问入口。
  2. TIPS:
    • 相对于类加载过程的其他阶段,非数组类型的加载阶段(准确地说,是加载阶段中获取类的二进制字节流的动作)是开发人员可控性最强的阶段,因为开发人员既可以使用系统提供的类加载器来完成加载,也可以自定义自己的类加载器来完成加载;
    • 对于数组类而言,情况就有所不同,数组类本身不通过类加载器创建,它是由Java虚拟机直接在内存中动态构造出来的;
    • 加载阶段完成后,虚拟机外部的二进制字节流就按照虚拟机所需的格式存储在方法区中,而且Java堆中也创建一个java.lang.Class类的对象,这样便可以通过该对象访问方法区中的这些数据;
    • 加载和链接可能是交替运行的。

链接

连接阶段可以细分为验证、准备、解析三个阶段。

验证
  1. 作用:验证确保被用户加载的类的正确性,是连接阶段的第一步,这一阶段的目的是为了确保Class文件的字节流中包含的信息符合当前虚拟机的要求,并且不会危害虚拟机自身的安全。
  2. 验证阶段大致会完成4个阶段的检验工作:
    • 文件格式验证:验证字节流是否符合Class文件格式的规范;例如:是否以 0xCAFEBABE开头、主次版本号是否在当前虚拟机的处理范围之内、常量池中的常量是否有不被支持的类型。
    • 元数据验证:对字节码描述的信息进行语义分析(注意:对比javac编译阶段的语义分析),以保证其描述的信息符合Java语言规范的要求;例如:这个类是否有除了 java.lang.Object 之外的父类。
    • 字节码验证:该阶段验证的主要工作是进行数据流和控制流分析,对类的方法体进行校验分析,以保证被校验的类的方法在运行时不会做出危害虚拟机安全的行为。
    • 符号引用验证:这是最后一个阶段的验证,它发生在虚拟机将符号引用转化为直接引用的时候(解析阶段中发生该转化,后面会有讲解),主要是对类自身以外的信息(常量池中的各种符号引用)进行匹配性的校验,确保解析动作能正确执行。
  3. 关闭:验证阶段不是必须的,关闭它可以类加载的时间。参数:-Xverify:none
准备
  1. 作用:为 static 变量分配空间,设置默认值。

  2. TIPS:

    • 默认赋予零值:

      • 对于类变量(static)和全局变量的基本类型来说,如果不显式地对其赋值而直接使用,系统会为其赋值默认的零值;

      • 对于引用数据类型reference来说,如数组引用、对象引用等,如果没有对其进行显式地赋值而直接使用,系统都会为其赋予默认的零值,即null;

      • 如果在数组初始化时没有对数组中的各个元素赋值,那么其中的元素将根据对应的数据类型而被赋予默认的零值。

    • 使用前需要显式地赋值:

      • 对于局部变量的基本类型来说来说,在使用前必须显式地为其赋值,否则编译时不通过;
      • 只被final修饰的常量既可以在声明时显式地为其赋值,也可以在类初始化时显式地为其赋值,总之,在使用前必须为其显式地赋值,系统不会为其赋值默认零值。
    • 同时被static和final修饰即常量属性,必须在声明的时候就为其显式地赋值,否则编译时不通过,常量属性在准备阶段该常量就会被初始化为其对应的值。

    • static变量在分配空间和赋值是在两个阶段完成的。分配空间在准备阶段完成,赋值在初始化阶段完成;

    • 如果 static 变量是 final 的基本类型,以及字符串常量,那么编译阶段值就确定了,赋值在准备阶段完成,如果 static 变量是 final 的,但属于引用类型,那么赋值也会在初始化阶段完成

解析
  1. 作用:将常量池中的符号引用解析为直接引用。(未解析时,常量池中的看到的对象仅是符号,未真正的存在于内存中)

  2. 四种引用的解析过程:

    • 类或接口:判断所要转化成的直接引用是对数组类型,还是普通的对象类型的引用,从而进行不同的解析。

    • 字段:对字段进行解析时,会先在本类中查找是否包含有简单名称和字段描述符都与目标相匹配的字段,如果有,则查找结束;如果没有,则会按照继承关系从上往下递归搜索该类所实现的各个接口和它们的父接口,还没有,则按照继承关系从上往下递归搜索其父类,直至查找结束。如下代码演示:

      /**
       * 测试解析阶段:
       * 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 类静态语句块");
          }
      }
    • 类方法:对类方法的解析与对字段解析的搜索步骤差不多,只是多了判断该方法所处的是类还是接口的步骤,而且对类方法的匹配搜索,是先搜索父类,再搜索接口。

    • 接口方法:与类方法解析步骤类似,知识接口不会有父类,因此,只递归向上搜索父接口就行了。

初始化

  1. 作用:初始化阶段就是执行类构造器clinit()方法的过程,虚拟机会保证这个类的『构造方法』的线程安全。

  2. clinit()方法是由编译器自动收集类中的所有类变量的赋值动作和静态语句块(static{}块)中的语句合并产生的,并且顺序是由语句在源文件中出现的顺序决定的,所以静态语句块中只能访问到定义在静态语句块之前的变量,定义在它之后的变量,在前面的静态语句块可以赋值,但是不能访问,例子如下:

    img

  3. 发生时机:

    • 类的初始化的懒惰的,以下情况会初始化:
      • main 方法所在的类,总会被首先初始化;
      • 首次访问这个类的静态变量或静态方法时;
      • 子类初始化,如果父类还没初始化,会引发;
      • 子类访问父类的静态变量,只会触发父类的初始化;
      • Class.forName;
      • new 会导致初始化。
    • 以下情况不会初始化:
      • 访问类的 static final 静态常量(基本类型和字符串);
      • 类对象.class 不会触发初始化;
      • 创建该类对象的数组;
      • 类加载器的.loadClass方法;
      • Class.forNamed的参数2为false时。

类加载器

Java虚拟机设计团队有意把类加载阶段中的“通过一个类的全限定名来获取描述该类的二进制字节流”这个动作放到Java虚拟机外部去实现,以便让应用程序自己决定如何去获取所需的类。实现这个动作的代码被称为“类加载器”(ClassLoader)[^1]。

类与类加载器

  1. 关系:类加载器虽然只用于实现类的加载动作,但它在 Java 程序中起到的作用却远超类加载阶段。对于任意一个类,都必须由加载它的类加载器和这个类本身一起共同确立其在Java虚拟机中的唯一性,每一个类加载器,都拥有一个独立的类名称空间。这句话可以表达得更通俗一些:比较两个类是否“相等”,只有在这两个类是由同一个类加载器加载的前提下才有意义,否则,即使这两个类来源于同一个 Class 文件,被同一个 Java 虚拟机加载,只要加载它们的类加载器不同,那这两个类就必定不相等。[^1]

  2. JDK8中的类加载器:

    名称 加载的类 说明
    Bootstrap ClassLoader(启动类加载器) JAVA_HOME/jre/lib 无法直接访问
    Extension ClassLoader(扩展类加载器) JAVA_HOME/jre/lib/ext 上级为Bootstrap,显示为null
    Application ClassLoader(应用程序类加载器) classpath 上级为Extension
    自定义类加载器 自定义 上级为Application
  3. 类加载器的层次关系

    有以下代码:

    public 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
             */
        }
    }

    说明类加载器的层次关系如下图所示:

    类加载器的层次关系

双亲委派模型

  1. 双亲委派模式,即调用类加载器ClassLoader 的 loadClass 方法时,查找类的规则。

  2. 注意:双亲委派模型要求除了顶层的启动类加载器外,其余的类加载器都应有自己的父类加载器。不过这里类加载器之间的父子关系一般不是以继承(Inheritance)的关系来实现的,而是通常使用组合(Composition)关系来复用父加载器的代码。

  3. 工作流程:如果一个类加载器收到了类加载的请求,它首先不会自己去尝试加载这个类,而是把这个请求委派给父类加载器去完成,每一个层次的类加载器都是如此,因此所有的加载请求最终都应该传送到最顶层的启动类加载器中,只有当父加载器反馈自己无法完成这个加载请求(它的搜索范围中没有找到所需的类)时,子加载器才会尝试自己去完成加载。

  4. loadClass源码:

    protected 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;
        }
    }

自定义类加载器

  1. 使用场景:
    • 想加载非 classpath 随意路径中的类文件;
    • 通过接口来使用实现,希望解耦时,常用在框架设计;
    • 这些类希望予以隔离,不同应用的同名类都可以加载,不冲突,常见于 tomcat 容器。
  2. 步骤:
    • 继承ClassLoader父类;
    • 要遵从双亲委派机制,重写findClass方法(不是重写loadClass方法,否则不会走双亲委派机制);
    • 读取类文件的字节码;
    • 调用父类的 defineClass 方法来加载类;
    • 使用者调用该类加载器的 loadClass 方法。

破坏双亲委派模型

  1. 双亲委派模型的第一次“被破坏”其实发生在双亲委派模型出现之前——即JDK1.2面世以前的“远古”时代,建议用户重写findClass()方法,在类加载器中的loadClass()方法中也会调用该方法。
  2. 双亲委派模型的第二次“被破坏”是由这个模型自身的缺陷导致的,如果有基础类型又要调用回用户的代码,此时也会破坏双亲委派模式。
  3. 双亲委派模型的第三次“被破坏”是由于用户对程序动态性的追求而导致的,这里所说的“动态性”指的是一些非常“热”门的名词:代码热替换(Hot Swap)、模块热部署(Hot Deployment)等。

文章作者: 一袖南烟顾
版权声明: 本博客所有文章除特別声明外,均采用 CC BY 4.0 许可协议。转载请注明来源 一袖南烟顾 !
评论
  目录