什么是抑制异常？

Question

(用户soc)对回答一个关于尾部调用优化的问题提到Java 7由于“添加了 ARM”（支持 ARM CPU？），有一个名为“抑制异常”的新功能。

在这种情况下，什么是“受抑制的异常”？在其他情况下，“抑制的异常”是捕获然后忽略的异常（很少是一个好主意）；这显然是不同的。

Answer 1

Java7之前；代码中抛出了异常，但不知何故被忽略了。

例如）

public class SuppressedExceptions {
  public static void main(String[] args) throws Exception {
    try {
        callTryFinallyBlock();
    } catch (Exception e) {
        e.printStackTrace(); **//Only Finally Exception is Caught**
    }
  }

  private static void callTryFinallyBlock() throws Exception {
    try 
    {
        throw new TryException(); **//This is lost**
    }
    finally
    {
        FinallyException fEx = new FinallyException();
        throw fEx;
    }
  }
}

class TryException extends Exception {
}

class FinallyException extends Exception {
}

JDK 7 中的 Throwable 类中添加了一个新的构造函数和两个新方法。
这些如下：

Throwable.getSupressed(); // Returns Throwable[]
Throwable.addSupressed(aThrowable);

通过这种新方法，我们也可以处理那些被抑制的异常。

public class SuppressedExceptions {
  public static void main(String[] args) throws Exception {
    try {
        callTryFinallyBlock();
    } catch (Exception e) {
        e.printStackTrace();
        for(Throwable t: e.getSuppressed())
        {
            t.printStackTrace();
        }
    }
  }

  private static void callTryFinallyBlock() throws Exception {
    Throwable t = null;
    try 
    {
        throw new TryException();
    }
    catch (Exception e) {
        t = e;
    }
    finally
    {
        FinallyException fEx = new FinallyException();
        if(t != null)fEx.addSuppressed(t);
        throw fEx;
    }
  }
}

class TryException extends Exception {
}

class FinallyException extends Exception {
}

在 Java7 中尝试资源； AutoCloseable::close() 处的异常
默认情况下与 try 异常一起添加为抑制异常。

另请注意，这与链式异常不同（随 JDK 1.4 引入，旨在以便轻松跟踪异常之间的因果关系。）

Answer 2

考虑到下面的代码：

public class MultipleExceptionsExample {

   static class IOManip implements Closeable{
       @Override
       public void close() {
           throw new RuntimeException("from IOManip.close");
       }
   }

   public static void main(String[] args) {
       try(IOManip ioManip = new IOManip()){
           throw new RuntimeException("from try!");
       }catch(Exception e){
           throw new RuntimeException("from catch!");
       }finally{
           throw new RuntimeException("from finally!");
       }
   }
}

对于所有行，您将得到： java.lang.RuntimeException: from finally!

删除 finally 块，您将得到： java.lang.RuntimeException : from catch!

删除 catch 块，您将得到：

Exception in thread "main" java.lang.RuntimeException: from try!
    Suppressed: java.lang.RuntimeException: from IOManip.close

Answer 3

抑制的异常 是 try-with-resources 语句中发生的其他异常 (在 Java 7 中引入）当 AutoCloseable 资源已关闭。由于关闭 AutoCloseable 资源时可能会发生多个异常，因此将附加异常附加到 主要异常作为抑制异常。

查看一段 try-with-resources 示例代码的字节码，标准 JVM 异常处理程序 用于适应 try-with-resources 语义。

Answer 4

您也可以在 Java 6 中抑制异常（涉及一些技巧），

我创建了一个实用程序，可以透明地处理 Java 1.6 和 Java 1.7 中的抑制异常。您可以找到实现 这里

您所需要的只是调用：

public static <T extends Throwable> T suppress(final T t, final Throwable suppressed) 

抑制异常，并

public static Throwable [] getSuppressed(final Throwable t) {

获取异常的抑制异常，以防有人仍然使用 Java 1.6

Answer 5

ARM - 自动资源管理（从 Java 7 开始引入）

举一个非常简单的例子

static String readFirstLineFromFileWithFinallyBlock(String path)
                                                     throws IOException {
    BufferedReader br = new BufferedReader(new FileReader(path));
    try {
        return br.readLine();
    } finally {
        if (br != null) br.close();
    }
}

现在如果 readLine() 函数抛出异常，然后甚至 close() 函数[在finally块中]抛出异常，然后后者被赋予更高的优先级并被扔回调用函数。在这种情况下，由 readLine() 方法抛出的异常将被忽略/抑制。您可以将引发异常链接到异常中，并从finally 块中重新抛出异常。

自java 7 以来，已经提供了检索被抑制的异常的功能。您可以在捕获的 throwable 对象上调用 public final java.lang.Throwable[] getSuppressed() 函数来查看抑制的异常。

对于例如。

static String readFirstLineFromFileWithFinallyBlock(String path)
        throws Exception {
    try (BufferedReader br = new BufferedReader(new FileReader(path));) {
        return br.readLine();
    }
}

现在，如果 br.readLine(); 行抛出 Exception1，然后假设在关闭资源时抛出 Exception2 [想象一下这发生在隐式finally 阻止 try-with-resource 语句创建]，然后 Exception1 抑制 Exception2。

这里有几点需要注意 -

1. 如果 try-with-resource 块抛出异常，即在资源实例化时，则 try 块将不会执行，并且将抛出相同的异常。
2. 如果资源实例化成功，try块抛出异常，并且在关闭资源时抛出异常，然后关闭资源时抛出的异常被try块抛出的异常抑制。
3. 如果您提供显式的finally块并且从该块抛出异常，它将抑制所有其他异常。 （这个显式的finally块在资源关闭后执行）

我已经在下面的文章中使用代码片段和输出编译了大多数可能的场景。

java 7 中的抑制异常

希望有所帮助。

Answer 6

我认为这与“链式异常设施”有关。随着堆栈跟踪的发展，它将影响该工具处理异常的方式。随着时间的推移，作为一组链式异常的一部分的异常可以被抑制。有关更多详细信息，请参阅Throwable 文档。

Answer 7

为了澄清乔恩答案中的引用，一种方法（每次执行）只能抛出一个异常，但在 try-with-resources 的情况下，可能会抛出多个异常。例如，一个可能会被抛出到块中，另一个可能会从 try-with-resources 提供的隐式 finally 中抛出。

编译器必须确定其中哪一个“真正”抛出。它选择抛出显式代码（try 块中的代码）引发的异常，而不是隐式代码（finally 块）引发的异常。因此，隐式块中引发的异常将被抑制（忽略）。这只发生在多个异常的情况下。

Answer 8

我相信评论者指的是一个异常，当它在 try-with-resources 块，在从 try 块抛出现有异常的上下文中：

与 try-with-resources 语句关联的代码块可能会引发异常。在 writeToFileZipFileContents 示例中，当尝试关闭 ZipFile 和 BufferedWriter 对象时，try 块可以引发异常，并且 try-with-resources 语句最多可以引发两个异常。如果 try 块中抛出了一个异常，并且 try-with-resources 语句中抛出了一个或多个异常，则 try-with-resources 语句中抛出的这些异常将被抑制，并且该块抛出的异常是第一个由 writeToFileZipFileContents 方法抛出。您可以通过从 try 块抛出的异常中调用 Throwable.getSuppressed 方法来检索这些被抑制的异常。

（这是引用链接页面中名为“抑制的异常”的部分。）