java虚拟机规范(se8)——java虚拟机的编译(四)

3.12 抛出和处理异常

　　在程序中使用throw关键字来抛出异常。编译结果很简单。

void cantBeZero(int i) throws TestExc {
    if (i == 0) {
        throw new TestExc();
    }
}

编译为：

Method void cantBeZero(int)
0   iload_1             // Push argument 1 (i)
1   ifne 12             // If i==0, allocate instance and throw
4   new #1              // Create instance of TestExc
7   dup                 // One reference goes to its constructor
8   invokespecial #7    // Method TestExc.<init>()V
11  athrow              // Second reference is thrown
12  return              // Never get here if we threw TestExc

使用try-catch构建的编译时直观的，例如：

void catchOne() {
    try {
        tryItOut();
    } catch (TestExc e) {
        handleExc(e);
    }
}

编译为：

Method void catchOne()
0   aload_0             // Beginning of try block
1   invokevirtual #6    // Method Example.tryItOut()V
4   return              // End of try block; normal return
5   astore_1            // Store thrown value in local var 1
6   aload_0             // Push this
7   aload_1             // Push thrown value
8   invokevirtual #5    // Invoke handler method: 
                        // Example.handleExc(LTestExc;)V
11  return              // Return after handling TestExc
Exception table:
From    To      Target      Type
0       4       5           Class TestExc

自己观察，try代码块编译后，就和try不存在一样：

Method void catchOne()
0   aload_0             // Beginning of try block
1   invokevirtual #6    // Method Example.tryItOut()V
4   return              // End of try block; normal return

　　在执行try代码块的时候，如果没有异常抛出，就和try不存在一样：tryItOut被调用然后catchOne返回。

　　在try块后面是实现单个catch语句的Java虚拟机代码。

5   astore_1            // Store thrown value in local var 1
6   aload_0             // Push this
7   aload_1             // Push thrown value
8   invokevirtual #5    // Invoke handler method: 
                        // Example.handleExc(LTestExc;)V
11  return              // Return after handling TestExc
Exception table:
From    To      Target      Type
0       4       5           Class TestExc

　　catch语句中的的内容——调用handlwExc，同样被编译为一个普通的方法调用。但是，catch语句的存在导致编译器生成一个异常表条目。catchOne方法的异常表有一个条目对应于catchOne的catch子句可以处理的一个参数（类TestExc的实例）。如果TestExc的某一个实例在指令执行catchOne的索引0到4之间抛出了，那么控制将转移到代码所有为5的位置，也就是实现了catch语句的代码块。如果抛出的异常不是TestExc的实例，catchOne的catch语句无法处理它。相应的，异常会抛给catchOne的调用者。

　　try可以有多个catch语句：

void catchTwo() {
    try {
        tryItOut();
    } catch (TestExc1 e) {
        handleExc(e);
    } catch (TestExc2 e) {
        handleExc(e);
    }
}

通过简单地为每个catch子句依次附加Java虚拟机代码并将条目添加到异常表中来编译给定try语句的多个catch子句，如下所示：

Method void catchTwo()
0   aload_0             // Begin try block
1   invokevirtual #5    // Method Example.tryItOut()V
4   return              // End of try block; normal return
5   astore_1            // Beginning of handler for TestExc1;
                        // Store thrown value in local var 1
6   aload_0             // Push this
7   aload_1             // Push thrown value
8   invokevirtual #7    // Invoke handler method:
                        // Example.handleExc(LTestExc1;)V
11  return              // Return after handling TestExc1
12  astore_1            // Beginning of handler for TestExc2;
                        // Store thrown value in local var 1
13  aload_0             // Push this
14  aload_1             // Push thrown value
15  invokevirtual #7    // Invoke handler method:
                        // Example.handleExc(LTestExc2;)V
18  return              // Return after handling TestExc2
Exception table:
From    To      Target      Type
0       4       5           Class TestExc1
0       4       12          Class TestExc2

　　如果在执行try子句期间（在索引0和4之间）抛出一个值，该值与一个或多个catch子句的参数匹配（值是一个或多个参数的实例），则选择第一个匹配的catch语句。 控制转移到该catch语句的块的Java虚拟机代码。 如果抛出的值与catchTwo的任何catch子句的参数不匹配，则Java虚拟机将重新抛出该值，而不调用catchTwo的任何catch语句中的代码。

　　嵌套的try-catch语句编译结果和try语句跟随多个catch是非常相似的：

void nestedCatch() {
    try {
        try {
            tryItOut();
        } catch (TestExc1 e) {
            handleExc1(e);
        }
    } catch (TestExc2 e) {
        handleExc2(e);
    }
}

编译为：

Method void nestedCatch()
0   aload_0             // Begin try block
1   invokevirtual #8    // Method Example.tryItOut()V
4   return              // End of try block; normal return
5   astore_1            // Beginning of handler for TestExc1;
                        // Store thrown value in local var 1
6   aload_0             // Push this
7   aload_1             // Push thrown value
8   invokevirtual #7    // Invoke handler method: 
                        // Example.handleExc1(LTestExc1;)V
11  return              // Return after handling TestExc1
12  astore_1            // Beginning of handler for TestExc2;
                        // Store thrown value in local var 1
13  aload_0             // Push this
14  aload_1             // Push thrown value
15  invokevirtual #6    // Invoke handler method:
                        // Example.handleExc2(LTestExc2;)V
18  return              // Return after handling TestExc2
Exception table:
From    To      Target      Type
0       4       5           Class TestExc1
0       12      12          Class TestExc2

　　catch语句的嵌套仅表现在异常表中，java虚拟机本身不要求异常表条目的顺序。但是，因为try-catch构造是结构化的，所以编译器总是可以对异常处理程序表的条目进行排序，这样，对于任何抛出的异常，都会被最接近异常位置的、可处理该异常的catch语句块所处理。

　　例如，如果tryItOut（在索引1处）的调用抛出TestExc1的实例，则它将由调用handleExc1的catch语句处理。 即使异常发生在外部catch语句能够处理的范围之内（捕获TestExc2的catch语句），并且外部的catch能够处理这个异常，也不会分配给外部的catch处理，因为异常表的顺序。

　　作为一个微妙的点，请注意catch子句的范围包含在“from”端，不包括“to”端（第4.7.3节）。 因此，捕获TestExc1的catch子句的异常表条目不包括偏移量为4的return指令。但是，捕获TestExc2的catch子句的异常表条目确实覆盖了偏移量11处的返回指令。因此，如果嵌套catch语句的return指令抛出异常，将由外出的catch语句处理。

3.13 编译finally

　　这节假设编译器在50.0或者更低的版本下生成的class文件，这样jsr指令可能被用到。见4.10.2.5

　　try-finally语句的编译和try-catch的编译时相似的。在执行完try代码块之前（无论有没有抛出异常），finally语句块的内容都将被执行。看一个简单的例子：

void tryFinally() {
    try {
        tryItOut();
    } finally {
        wrapItUp();
    }
}

编译后的代码：

Method void tryFinally()
0   aload_0             // Beginning of try block
1   invokevirtual #6    // Method Example.tryItOut()V
4   jsr 14              // Call finally block
7   return              // End of try block
8   astore_1            // Beginning of handler for any throw
9   jsr 14              // Call finally block
12  aload_1             // Push thrown value
13  athrow              // ...and rethrow value to the invoker
14  astore_2            // Beginning of finally block
15  aload_0             // Push this
16  invokevirtual #5    // Method Example.wrapItUp()V
19  ret 2               // Return from finally block
Exception table:
From    To      Target      Type
0       4       8           any

　　控制传递到try语句之外有四种方法：执行完代码块，返回，执行break或continue语句，或者引发异常。 如果tryItOut返回而没有引发异常，则使用jsr指令将控制转移到finally块。 索引4处的jsr 14指令对索引14处的finally块的代码进行“子程序调用”（finally块被编译为嵌入式子例程）。 当finally块完成时，ret 2指令将控制返回到索引4处的jsr指令之后的指令。

　　更详细地说，子例程调用的工作原理如下：jsr指令在跳转之前将下一条指令的地址（在索引7处返回）推送到操作数堆栈上。 作为跳转目标的astore_2指令将操作数堆栈上的地址存储到本地变量2中。运行finally块的代码（在本例中为aload_0和invokevirtual指令）。 假设该代码的执行正常完成，则ret指令从局部变量2中检索地址并在该地址处继续执行。 执行返回指令，tryFinally正常返回。

　　更详细地说，子例程调用的工作原理如下：jsr指令在跳转之前将下一条指令的地址（在索引7处返回）推送到操作数堆栈上。 作为跳转目标的astore_2指令将操作数堆栈上的地址存储到本地变量2中。运行finally块的代码（在本例中为aload_0和invokevirtual指令）。 假设该代码的执行正常完成，则ret指令从局部变量2中检索地址并在该地址处继续执行。 执行返回指令，tryFinally正常返回。

　　编译包含catch和finally语句的try语句会更复杂一点：

void tryCatchFinally() {
    try {
        tryItOut();
    } catch (TestExc e) {
        handleExc(e);
    } finally {
        wrapItUp();
    }
}

编译为：

Method void tryCatchFinally()
0   aload_0             // Beginning of try block
1   invokevirtual #4    // Method Example.tryItOut()V
4   goto 16             // Jump to finally block
7   astore_3            // Beginning of handler for TestExc;
                        // Store thrown value in local var 3
8   aload_0             // Push this
9   aload_3             // Push thrown value
10  invokevirtual #6    // Invoke handler method:
                        // Example.handleExc(LTestExc;)V
13  goto 16             // This goto is unnecessary, but was
                        // generated by javac in JDK 1.0.2
16  jsr 26              // Call finally block
19  return              // Return after handling TestExc
20  astore_1            // Beginning of handler for exceptions
                        // other than TestExc, or exceptions
                        // thrown while handling TestExc
21  jsr 26              // Call finally block
24  aload_1             // Push thrown value...
25  athrow              // ...and rethrow value to the invoker
26  astore_2            // Beginning of finally block
27  aload_0             // Push this
28  invokevirtual #5    // Method Example.wrapItUp()V
31  ret 2               // Return from finally block
Exception table:
From    To      Target      Type
0       4       7           Class TestExc
0       16      20          any

如果try语句正常完成，则索引4处的goto指令跳转到索引16处finally块的子例程调用。执行索引26处的finally块，控制返回索引19处的返回指令，并且tryCatchFinally正常返回。

　　如果tryItOut抛出TestExc的实例，则选择异常表中的第一个（最上层的）适用的异常处理程序来处理异常。 从索引7开始，该异常处理程序的代码将抛出的值传递给handleExc，并且在其返回时对索引26处的finally块进行相同的子例程调用，如同正常情况一样。 如果handleExc没有抛出异常，则tryCatchFinally会正常返回。

　　如果tryItOut抛出的值不是TestExc的实例，或者如果handleExc本身抛出异常，则该条件由异常表中的第二个条目处理，该条件处理索引0和16之间抛出的任何值。该异常处理程序将控制转移到 索引20，其中抛出的值首先存储在局部变量1中。索引26处的finally块的代码被称为子例程。 如果返回，则从局部变量1检索抛出的值，并使用athrow指令重新抛出。 如果在执行finally子句期间抛出新值，则finally子句将中止，并且tryCatchFinally异常返回，将新值抛给其调用者。

3.14 同步

　　java虚拟机是用过monitor的进入和退出来实现同步的，不管是显示（使用monitorenter和monitorexit指令）或者隐式（通过方法调用和return指令）。

　　java编程语言编写的代码，可能最通用的同步形式就是同步方法。同步方法不是通过monitorenter和monitorexit简单实现。而是简单通过运行时常量池中的ACC_SYNCHRONIZED标识来区分，通过方法调用指令来检查这个标识。

　　monitorenter和monitorexit指令用同步代码块的编译。例如：

void onlyMe(Foo f) {
    synchronized(f) {
        doSomething();
    }
}

编译为：

Method void onlyMe(Foo)
0   aload_1             // Push f
1   dup                 // Duplicate it on the stack
2   astore_2            // Store duplicate in local variable 2
3   monitorenter        // Enter the monitor associated with f
4   aload_0             // Holding the monitor, pass this and...
5   invokevirtual #5    // ...call Example.doSomething()V
8   aload_2             // Push local variable 2 (f)
9   monitorexit         // Exit the monitor associated with f
10  goto 18             // Complete the method normally
13  astore_3            // In case of any throw, end up here
14  aload_2             // Push local variable 2 (f)
15  monitorexit         // Be sure to exit the monitor!
16  aload_3             // Push thrown value...
17  athrow              // ...and rethrow value to the invoker
18  return              // Return in the normal case
Exception table:
From    To      Target      Type
4       10      13          any
13      16      13          any

编译器确保在任何方法调用完成时，将对自方法调用以来执行的每个monitorenter指令执行monitorexit指令。 无论方法调用是正常完成（第2.6.4节）还是异常完成（第2.6.5节），都是如此。 为了在方法异常调用完成时保证monitorenter和monitorexit指令的配对，编译器会生成异常处理程序（第2.10节），它将匹配任何异常并且其相关代码执行必要的monitorexit指令。

3.15 注解

　　4.7.16-4.7.22节中给出了注解在class文件中表示。这些章节中明确描述了在class文件格式中，如何描述修饰类型，字段和方法的注解。这里只描述关于注解的一些额外规则。

　　当编译器遇到必须在运行时可用的带注释的包声明时，它会生成一个具有以下属性的class文件：

• class文件表示的是一个接口，那么ACC_INTERFACE和ACC_ABSTRACT标识在ClassFile的结构中被设置
• 如果class文件的版本号低于50.0，然后ACC_SYNTHETIC标识不会设置；如果版本号大于等于50.0，那么ACC_SYNTHETIC标识被设置。
• 接口具有包访问权限。
• 接口的名称是package-name.package-info的内部形式。
• 这个接口没有父类
• 接口的唯一成员是Java语言规范Java SE 8 Edition（JLS§9.2）所暗示的成员。
• 声明上的注释在ClassFile结构的属性表中存储为RuntimeVisibleAnnotations和RuntimeInvisibleAnnotations属性。