跳到主要内容

Java Finally块

什么是finally块​

在Java异常处理机制中，finally块是与try-catch结构一起使用的重要组成部分。无论异常是否被捕获，finally块中的代码都会执行，这使得它成为执行清理代码的理想位置。

finally块通常用于释放在try块中获取的资源，例如关闭文件、数据库连接或网络连接，无论程序执行是否正常都能确保这些资源被正确释放。

finally块的基本语法​

finally块的基本语法如下：

java
try {
    // 可能抛出异常的代码
} catch (ExceptionType e) {
    // 处理异常的代码
} finally {
    // 无论是否发生异常都会执行的代码
}

也可以不使用catch块，直接使用try-finally结构：

java
try {
    // 可能抛出异常的代码
} finally {
    // 无论是否发生异常都会执行的代码
}

finally块的执行时机​

finally块的执行时机是Java异常处理中非常重要的知识点：

  1. 当try块正常结束时，执行finally块
  2. 当try块因为异常结束，并且该异常被catch块捕获时，在执行完catch块后，执行finally块
  3. 当try块因为异常结束，但异常未被捕获时，会先执行finally块，然后传递异常给上一级调用者
备注

即使在try或catch块中执行了return语句，finally块也会在方法返回前被执行！

看一个执行顺序的例子：

java
public class FinallyExecutionDemo {
    public static void main(String[] args) {
        System.out.println(testFinally());
    }
    
    public static String testFinally() {
        try {
            System.out.println("执行try块");
            return "try的返回值";
        } catch (Exception e) {
            System.out.println("执行catch块");
            return "catch的返回值";
        } finally {
            System.out.println("执行finally块");
        }
    }
}

输出：

执行try块
执行finally块
try的返回值
警告

注意：虽然finally块会在return语句之前执行，但return语句的表达式计算发生在finally块执行之前。

finally块中的return语句​

一个常见的错误是在finally块中使用return语句。当finally块包含return语句时，它会覆盖try或catch块中的返回值。

java
public class FinallyReturnDemo {
    public static void main(String[] args) {
        System.out.println(testFinallyReturn());
    }
    
    public static int testFinallyReturn() {
        try {
            return 1;  // 这个返回值会被忽略
        } finally {
            return 2;  // finally块的返回值会覆盖try块的返回值
        }
    }
}

输出：

2
注意

不要在finally块中使用return语句，这会使代码难以理解并可能导致意外行为。

finally块不会执行的情况​

尽管finally块几乎总是会执行，但还是有几种情况下它不会被执行：

  1. 当程序在try或catch块中调用System.exit()时
  2. 当程序在try或catch块中遇到致命错误（如JVM崩溃）时
  3. 当运行try块的线程被中断或终止时
java
public class FinallyNoExecuteDemo {
    public static void main(String[] args) {
        try {
            System.out.println("在try块中");
            System.exit(0);  // 程序终止，finally块不会执行
        } finally {
            System.out.println("在finally块中");  // 这行代码不会执行
        }
    }
}

输出：

在try块中

finally块的实际应用场景​

1. 资源关闭​

最常见的应用场景是确保资源的正确关闭，例如文件、数据库连接或网络连接：

java
FileInputStream fis = null;
try {
    fis = new FileInputStream("file.txt");
    // 使用文件进行操作
} catch (IOException e) {
    // 处理异常
} finally {
    if (fis != null) {
        try {
            fis.close();  // 确保文件被关闭
        } catch (IOException e) {
            // 处理关闭时的异常
        }
    }
}

2. 锁的释放​

在多线程编程中，确保锁资源被正确释放：

java
Lock lock = new ReentrantLock();
try {
    lock.lock();  // 获取锁
    // 执行需要同步的代码
} finally {
    lock.unlock();  // 确保锁被释放
}

3. 事务处理​

在数据库事务处理中，确保事务被正确提交或回滚：

java
Connection conn = null;
try {
    conn = getConnection();
    conn.setAutoCommit(false);  // 开始事务
    // 执行数据库操作
    conn.commit();  // 提交事务
} catch (SQLException e) {
    if (conn != null) {
        try {
            conn.rollback();  // 发生异常，回滚事务
        } catch (SQLException ex) {
            // 处理回滚时的异常
        }
    }
} finally {
    if (conn != null) {
        try {
            conn.close();  // 关闭数据库连接
        } catch (SQLException e) {
            // 处理关闭连接时的异常
        }
    }
}

替代方案：try-with-resources​

自Java 7引入了try-with-resources语法，它提供了一种更简洁的方式来管理资源，并且不再需要显式的finally块：

java
try (FileInputStream fis = new FileInputStream("file.txt")) {
    // 使用文件进行操作
} catch (IOException e) {
    // 处理异常
}
// 不需要finally块，资源会自动关闭

要使用try-with-resources，资源类必须实现AutoCloseable接口。

提示

对于需要自动关闭资源的场景，推荐使用try-with-resources而不是传统的try-catch-finally结构，它使代码更简洁且不容易出错。

finally块与异常抑制​

如果try块和finally块都抛出异常，那么try块的异常会被抑制（suppressed），而finally块的异常会被传播：

java
public class ExceptionSuppression {
    public static void main(String[] args) {
        try {
            throwException();
        } catch (Exception e) {
            System.out.println("捕获的异常: " + e.getMessage());
        }
    }
    
    public static void throwException() throws Exception {
        try {
            throw new Exception("try块异常");  // 这个异常会被抑制
        } finally {
            throw new Exception("finally块异常");  // 这个异常会被传播
        }
    }
}

输出：

捕获的异常: finally块异常
警告

这种行为可能导致调试困难，因为原始异常信息可能会丢失。在Java 7之后，可以使用Throwable.getSuppressed()方法来获取被抑制的异常。

总结​

finally块是Java异常处理机制中的重要组成部分，它可以确保无论是否发生异常，某些代码（通常是资源清理）都会被执行。关于finally块的主要要点：

  • finally块总是会执行，除非JVM退出或线程被终止
  • finally块通常用于资源清理，如关闭文件、数据库连接等
  • 不建议在finally块中使用return语句
  • 从Java 7开始，可以使用try-with-resources语法作为更简洁的替代方案
  • 如果try和finally块都抛出异常，finally块中的异常会覆盖try块中的异常

练习​

  1. 编写一个程序，使用try-catch-finally结构读取文件内容，确保文件正确关闭。
  2. 修改上述程序，使用try-with-resources代替try-catch-finally结构。
  3. 编写一个方法，演示finally块中的异常如何影响try块中的异常传播。
  4. 实现一个简单的数据库连接池，并确保连接在使用后正确返回池中。

进一步阅读​

通过掌握finally块的使用，你可以编写更健壮的Java程序，确保资源得到正确释放，从而避免内存泄漏和其他资源相关的问题。