JVM——JVM 是如何处理异常的？

JVM 是如何处理异常的？

在 Java 编程语言中，异常处理是一种强大的机制，用于应对程序运行时出现的错误和意外情况。而 Java 虚拟机（JVM）作为 Java 程序运行的核心环境，在异常处理过程中扮演着至关重要的角色。下面我们深入探讨 JVM 是如何处理异常的，从异常的基本概念、抛出与捕获机制、异常处理的性能影响，到 Java 7 引入的新特性等多个方面，进行全面而详细的剖析。

异常的基本概念

在 Java 语言规范中，所有异常都是 Throwable 类或者其子类的实例。Throwable 类有两个直接子类：Error 和 Exception。

Error ：表示程序不应捕获的异常。当程序触发 Error 时，通常意味着程序的执行状态已经无法恢复，需要中止线程甚至是中止虚拟机。例如，OutOfMemoryError 表示内存溢出错误，VirtualMachineError 表示虚拟机错误等。这些错误往往是由系统级问题或资源耗尽等问题引起的，应用程序一般无法对其进行有效的处理。
Exception ：涵盖程序可能需要捕获并且处理的异常。Exception 类又可以分为 RuntimeException 和其他类型的异常（即检查异常）。

RuntimeException 用来表示 “程序虽然无法继续执行，但是还能抢救一下” 的情况，如 ArrayIndexOutOfBoundsException（数组索引越界异常）、NullPointerException（空指针异常）等。RuntimeException 和 Error 属于 Java 里的非检查异常（unchecked exception），而其他异常则属于检查异常（checked exception）。

在 Java 语法中，所有的检查异常都需要程序显式地捕获，或者在方法声明中用 throws 关键字标注。通常情况下，程序中自定义的异常应为检查异常，以便最大化利用 Java 编译器的编译时检查。这种检查机制可以在编译阶段帮助开发者发现潜在的异常处理问题，提高程序的健壮性。

异常的抛出与捕获机制

（一）抛出异常

抛出异常可分为显式和隐式两种。

显式抛异常 ：主体是应用程序，指的是在程序中使用 “throw” 关键字，手动将异常实例抛出。例如下面代码中，当年龄为负数时，程序显式地抛出一个 IllegalArgumentException 异常，提示年龄不能为负数。
```
if (age < 0) {throw new IllegalArgumentException("年龄不能为负数");
}
```
隐式抛异常 ：主体则是 Java 虚拟机，它指的是 Java 虚拟机在执行过程中，碰到无法继续执行的异常状态，自动抛出异常。例如，Java 虚拟机在执行读取数组操作时，发现输入的索引值是负数，故而抛出数组索引越界异常（ArrayIndexOutOfBoundsException）：
```
 int[] arr = new int[5]; int value = arr[-1]; // 隐式抛出 ArrayIndexOutOfBoundsException
```

（二）捕获异常

捕获异常涉及如下三种代码块：

try 代码块 ：用来标记需要进行异常监控的代码。开发者将可能抛出异常的代码放在 try 块中，以便 JVM 对其进行监控。
catch 代码块 ：跟在 try 代码块之后，用来捕获在 try 代码块中触发的某种指定类型的异常。除了声明所捕获异常的类型之外，catch 代码块还定义了针对该异常类型的异常处理器。在 Java 中，try 代码块后面可以跟着多个 catch 代码块，来捕获不同类型的异常。Java 虚拟机会从上至下匹配异常处理器。因此，前面的 catch 代码块所捕获的异常类型不能覆盖后边的，否则编译器会报错。例如下面例子中，如果 try 块中的代码抛出了 IOException，则会被第一个 catch 块捕获并处理；如果抛出了其他类型的异常（如 NullPointerException 等），则会被第二个 catch 块捕获并处理。
```
try {// 可能抛出多种异常的代码
} catch (IOException e) {// 处理 IOException 异常
} catch (Exception e) {// 处理其他类型的异常
}
```
finally 代码块 ：跟在 try 代码块和 catch 代码块之后，用来声明一段必定运行的代码。它的设计初衷是为了避免跳过某些关键的清理代码，例如关闭已打开的系统资源。在程序正常执行的情况下，这段代码会在 try 代码块之后运行。否则，也就是 try 代码块触发异常的情况下：
- 如果该异常没有被捕获，finally 代码块会直接运行，并且在运行之后重新抛出该异常。
- 如果该异常被 catch 代码块捕获，finally 代码块则在 catch 代码块之后运行。在某些不幸的情况下，catch 代码块也触发了异常，那么 finally 代码块同样会运行，并会抛出 catch 代码块触发的异常。在某些极端不幸的情况下，finally 代码块也触发了异常，那么只好中断当前 finally 代码块的执行，并往外抛异常。

JVM 如何捕获异常

在编译生成的字节码中，每个方法都附带一个异常表。异常表中的每一个条目代表一个异常处理器，并且由 from 指针、to 指针、target 指针以及所捕获的异常类型构成。这些指针的值是字节码索引（bytecode index，bci），用以定位字节码。

其中，from 指针和 to 指针标示了该异常处理器所监控的范围，例如 try 代码块所覆盖的范围。target 指针则指向异常处理器的起始位置，例如 catch 代码块的起始位置。

举个例子，在以下代码中：

public static void main(String[] args) {try {mayThrowException();} catch (Exception e) {e.printStackTrace();}
}

编译过后，该方法的异常表拥有一个条目。其 from 指针和 to 指针分别为 0 和 3，代表它的监控范围从索引为 0 的字节码开始，到索引为 3 的字节码结束（不包括 3）。该条目的 target 指针是 6，代表这个异常处理器从索引为 6 的字节码开始。条目的最后一列，代表该异常处理器所捕获的异常类型正是 Exception。

当程序触发异常时，Java 虚拟机会从上至下遍历异常表中的所有条目。当触发异常的字节码的索引值在某个异常表条目的监控范围内，Java 虚拟机会判断所抛出的异常和该条目想要捕获的异常是否匹配。如果匹配，Java 虚拟机会将控制流转移至该条目 target 指针指向的字节码。

如果遍历完所有异常表条目，Java 虚拟机仍未匹配到异常处理器，那么它会弹出当前方法对应的 Java 栈帧，并且在调用者（caller）中重复上述操作。在最坏情况下，Java 虚拟机需要遍历当前线程 Java 栈上所有方法的异常表。

异常处理的性能影响

异常实例的构造十分昂贵。这是由于在构造异常实例时，Java 虚拟机便需要生成该异常的栈轨迹（stack trace）。该操作会逐一访问当前线程的 Java 栈帧，并且记录下各种调试信息，包括栈帧所指向方法的名字，方法所在的类名、文件名，以及在代码中的第几行触发该异常。

当然，在生成栈轨迹时，Java 虚拟机会忽略掉异常构造器以及填充栈帧的 Java 方法（Throwable.fillInStackTrace），直接从新建异常位置开始算起。此外，Java 虚拟机还会忽略标记为不可见的 Java 方法栈帧。

既然异常实例的构造十分昂贵，那么在实践中，我们应尽量避免频繁抛出和捕获异常，以免对程序性能造成较大影响。例如，在循环中抛出和捕获异常可能会导致程序运行缓慢。

Java 7 的新特性

（一）Supressed 异常

Java 7 引入了 Supressed 异常来解决异常链问题。这个新特性允许开发人员将一个异常附于另一个异常之上。因此，抛出的异常可以附带多个异常的信息。

然而，Java 层面的 finally 代码块缺少指向所捕获异常的引用，所以这个新特性使用起来非常繁琐。为此，Java 7 专门构造了一个名为 try-with-resources 的语法糖，在字节码层面自动使用 Supressed 异常。

（二）try-with-resources

try-with-resources 语法糖的主要目的是精简资源打开关闭的用法。在 Java 7 之前，对于打开的资源，我们需要定义一个 finally 代码块，来确保该资源在正常或者异常执行状况下都能关闭。资源的关闭操作本身容易触发异常。因此，如果同时打开多个资源，那么每一个资源都要对应一个独立的 try-finally 代码块，以保证每个资源都能够关闭。这样一来，代码将会变得十分繁琐。

Java 7 的 try-with-resources 语法糖极大地简化了上述代码。程序可以在 try 关键字后声明并实例化实现了 AutoCloseable 接口的类，编译器将自动添加对应的 close() 操作。在声明多个 AutoCloseable 实例的情况下，编译生成的字节码类似于上面手工编写代码的编译结果。与手工代码相比，try-with-resources 还会使用 Supressed 异常的功能，来避免原异常 “被消失”。

例如：

public class Foo implements AutoCloseable {private final String name;public Foo(String name) { this.name = name; }@Overridepublic void close() {throw new RuntimeException(name);}public static void main(String[] args) {try (Foo foo0 = new Foo("Foo0");Foo foo1 = new Foo("Foo1");Foo foo2 = new Foo("Foo2")) {throw new RuntimeException("Initial");}}
}

运行结果：

Exception in thread "main" java.lang.RuntimeException: Initialat Foo.main(Foo.java:18)Suppressed: java.lang.RuntimeException: Foo2at Foo.close(Foo.java:13)at Foo.main(Foo.java:19)Suppressed: java.lang.RuntimeException: Foo1at Foo.close(Foo.java:13)at Foo.main(Foo.java:19)Suppressed: java.lang.RuntimeException: Foo0at Foo.close(Foo.java:13)at Foo.main(Foo.java:19)

（三）多异常捕获

Java 7 还支持在同一 catch 代码块中捕获多种异常。实际实现非常简单，生成多个异常表条目即可。例如：

try {// 可能抛出多种异常的代码
} catch (IOException | SQLException e) {// 处理多种异常
}

实践分析

为了更好地理解 JVM 如何处理异常，我们可以进行一些实践分析。例如，查看以下代码：

public class Foo {private int tryBlock;private int catchBlock;private int finallyBlock;private int methodExit;public void test() {for (int i = 0; i < 100; i++) {try {tryBlock = 0;if (i < 50) {continue;} else if (i < 80) {break;} else {return;}} catch (Exception e) {catchBlock = 1;} finally {finallyBlock = 2;}}methodExit = 3;}
}

我们可以使用 javap -c 命令查看编译后的字节码，分析异常处理的机制。通过观察字节码，我们可以更深入地了解 JVM 如何处理 try-catch-finally 代码块，以及异常表条目的生成和匹配过程。