JAVA 文件流未关闭导致磁盘句柄泄漏？try-with-resources 正确用法讲解

大家好，今天我们来聊聊Java中文件流操作中一个非常常见但又容易被忽视的问题：文件句柄泄漏。以及如何利用 try-with-resources 优雅地解决这个问题。

什么是文件句柄泄漏？

在操作系统层面，当我们打开一个文件进行读写操作时，操作系统会分配一个文件句柄 (file handle) 给这个文件。文件句柄是一个指向文件系统资源的指针，它允许程序访问和操作文件。

当程序完成对文件的操作后，应该及时关闭文件流，释放这个文件句柄。如果程序没有正确关闭文件流，那么这个文件句柄就会一直被占用，即使程序本身已经不再使用这个文件。这就是文件句柄泄漏。

文件句柄泄漏的危害：

资源耗尽： 操作系统的文件句柄数量是有限的。如果程序持续泄漏文件句柄，最终会导致操作系统耗尽所有可用的文件句柄，使得其他程序无法打开新的文件。
程序崩溃： 某些操作系统在文件句柄耗尽时，可能会强制终止泄漏文件句柄的程序。
系统性能下降： 大量未释放的文件句柄会增加操作系统的负担，导致系统性能下降。
数据损坏： 在某些情况下，未正确关闭的文件流可能会导致数据丢失或损坏。比如，写入缓冲区的数据没有及时刷新到磁盘。

为什么会发生文件句柄泄漏？

最常见的原因是程序员忘记在程序中显式地关闭文件流。这通常发生在以下情况下：

异常处理不当： 如果在文件操作过程中发生异常，而异常处理代码没有正确关闭文件流，就会导致文件句柄泄漏。
代码逻辑复杂： 在复杂的代码逻辑中，很容易忘记在所有可能的执行路径上都关闭文件流。
缺乏意识： 有些程序员可能没有意识到文件句柄泄漏的潜在危害，因此没有养成良好的编程习惯。

传统的文件流关闭方式及问题

在Java 7之前，我们通常使用 try-catch-finally 块来保证文件流能够被正确关闭：

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class TraditionalFileHandling {

    public static void main(String[] args) {
        BufferedReader br = null;
        try {
            br = new BufferedReader(new FileReader("example.txt"));
            String line;
            while ((line = br.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (br != null) {
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

代码解释：

首先，在 try 块中创建 BufferedReader 对象，用于读取文件 "example.txt"。
然后，使用 while 循环逐行读取文件内容并打印到控制台。
如果在 try 块中发生 IOException 异常，则会跳转到 catch 块进行处理，打印异常堆栈信息。
无论 try 块是否发生异常，都会执行 finally 块中的代码。
在 finally 块中，首先判断 br 是否为 null，如果不为 null，则尝试关闭 BufferedReader 对象。
如果在关闭 BufferedReader 对象时发生 IOException 异常，则会打印异常堆栈信息。

这种方式存在以下问题：

代码冗余： 需要编写大量的 try-catch-finally 块来保证文件流的关闭，使得代码显得冗余和难以阅读。
容易出错： 即使使用了 try-catch-finally 块，仍然可能因为疏忽而忘记关闭文件流，或者在关闭文件流时发生异常而导致文件句柄泄漏。
可读性差： 嵌套的 try-catch-finally 块降低了代码的可读性和可维护性。

`try-with-resources` 语句：优雅的解决方案

Java 7 引入了 try-with-resources 语句，它提供了一种更加简洁和安全的方式来管理资源，特别是文件流。try-with-resources 语句可以自动关闭实现了 java.lang.AutoCloseable 接口的资源。

AutoCloseable 接口：

AutoCloseable 接口只有一个方法：

void close() throws Exception;

任何实现了 AutoCloseable 接口的类，都必须实现 close() 方法，用于释放资源。

try-with-resources 语句的语法：

try (ResourceType resource = new ResourceType()) {
    // 使用 resource
} catch (Exception e) {
    // 处理异常
}

代码解释：

在 try 关键字后面的括号中，声明并初始化一个或多个资源。这些资源必须实现了 AutoCloseable 接口。
在 try 块中，可以使用这些资源进行操作。
当 try 块执行完毕（无论是正常结束还是因为异常而结束），try-with-resources 语句会自动调用资源的 close() 方法来释放资源。

使用 try-with-resources 语句改进文件流处理：

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class TryWithResourcesFileHandling {

    public static void main(String[] args) {
        try (BufferedReader br = new BufferedReader(new FileReader("example.txt"))) {
            String line;
            while ((line = br.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

代码解释：

在 try 关键字后面的括号中，声明并初始化 BufferedReader 对象。
在 try 块中，使用 BufferedReader 对象读取文件内容并打印到控制台。
当 try 块执行完毕，try-with-resources 语句会自动调用 BufferedReader 对象的 close() 方法来关闭文件流。

try-with-resources 语句的优点：

简洁： 代码更加简洁，不需要显式地编写 try-catch-finally 块来关闭资源。
安全： 自动关闭资源，避免了因为忘记关闭资源而导致的文件句柄泄漏。
可读性强： 代码可读性更强，更容易理解。
异常处理： 如果在关闭资源时发生异常，try-with-resources 语句会自动抑制（suppress）原始异常，并将关闭异常添加到原始异常的 suppressed exceptions 列表中。这有助于更好地诊断问题。

`try-with-resources` 与多个资源

try-with-resources 语句可以同时管理多个资源，只需要用分号 (;) 将它们分隔开即可：

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class TryWithResourcesMultiple {

    public static void main(String[] args) {
        try (FileInputStream fis = new FileInputStream("input.txt");
             FileOutputStream fos = new FileOutputStream("output.txt")) {
            int data;
            while ((data = fis.read()) != -1) {
                fos.write(data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

代码解释：

在 try 关键字后面的括号中，声明并初始化 FileInputStream 和 FileOutputStream 对象，用分号分隔。
在 try 块中，使用 FileInputStream 对象读取 "input.txt" 文件的内容，并使用 FileOutputStream 对象将内容写入 "output.txt" 文件。
当 try 块执行完毕，try-with-resources 语句会自动调用 FileInputStream 和 FileOutputStream 对象的 close() 方法来关闭文件流。关闭的顺序与声明的顺序相反，即先关闭 FileOutputStream，再关闭 FileInputStream。

异常的抑制 (Suppression)

try-with-resources 的一个重要特性是异常抑制。如果 try 块中抛出一个异常，并且在关闭资源时也抛出一个异常，那么关闭资源时抛出的异常会被抑制，原始异常会被抛出。被抑制的异常可以通过 Throwable.getSuppressed() 方法访问。

import java.io.FileOutputStream;
import java.io.IOException;

public class TryWithResourcesSuppressedException {

    public static void main(String[] args) {
        try (FileOutputStream fos = new FileOutputStream("example.txt")) {
            // 模拟 try 块中抛出异常
            throw new IOException("Error writing to file");
        } catch (IOException e) {
            System.err.println("Caught exception: " + e.getMessage());
            Throwable[] suppressedExceptions = e.getSuppressed();
            if (suppressedExceptions != null && suppressedExceptions.length > 0) {
                System.err.println("Suppressed exceptions:");
                for (Throwable suppressedException : suppressedExceptions) {
                    System.err.println("t" + suppressedException.getMessage());
                }
            }
        }
    }
}

在这个例子中，try 块中抛出了一个 IOException，同时 FileOutputStream 的 close() 方法也可能抛出 IOException。在这种情况下，原始的 "Error writing to file" 异常会被抛出，而 close() 方法抛出的异常会被抑制。

为什么需要异常抑制？

异常抑制可以防止关闭资源时抛出的异常掩盖原始异常。原始异常通常更能反映问题的根本原因。通过访问被抑制的异常，可以获取更多关于资源关闭过程中的错误信息，有助于更好地诊断和解决问题。

哪些类可以使用 `try-with-resources`？

任何实现了 java.lang.AutoCloseable 接口的类都可以使用 try-with-resources 语句。Java 标准库中有很多类实现了 AutoCloseable 接口，例如：

类名	描述
`java.io.InputStream`	所有输入流的基类，例如 `FileInputStream`, `ByteArrayInputStream` 等。
`java.io.OutputStream`	所有输出流的基类，例如 `FileOutputStream`, `ByteArrayOutputStream` 等。
`java.io.Reader`	所有字符输入流的基类，例如 `FileReader`, `BufferedReader` 等。
`java.io.Writer`	所有字符输出流的基类，例如 `FileWriter`, `BufferedWriter` 等。
`java.net.Socket`	套接字
`java.sql.Connection`	数据库连接
`java.sql.Statement`	SQL 语句
`java.sql.ResultSet`	数据库查询结果集
`java.util.zip.ZipFile`	ZIP 文件
`java.nio.channels.Channel`	NIO 通道

除了 Java 标准库中的类，你也可以自定义实现了 AutoCloseable 接口的类，以便在 try-with-resources 语句中使用。

自定义 `AutoCloseable` 类

public class MyResource implements AutoCloseable {

    public MyResource() {
        System.out.println("Resource acquired.");
    }

    public void doSomething() {
        System.out.println("Doing something with the resource.");
    }

    @Override
    public void close() throws Exception {
        System.out.println("Resource released.");
    }

    public static void main(String[] args) {
        try (MyResource resource = new MyResource()) {
            resource.doSomething();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

代码解释：

MyResource 类实现了 AutoCloseable 接口，并实现了 close() 方法。
在 close() 方法中，我们打印一条消息 "Resource released."，表示资源已被释放。
在 main() 方法中，我们使用 try-with-resources 语句创建 MyResource 对象。
在 try 块中，我们调用 resource.doSomething() 方法来使用资源。
当 try 块执行完毕，try-with-resources 语句会自动调用 MyResource 对象的 close() 方法来释放资源。

何时应该使用 `try-with-resources`？

只要你处理的资源实现了 java.lang.AutoCloseable 接口，就应该尽可能地使用 try-with-resources 语句。这可以简化代码，提高代码的可读性和可维护性，并避免因为忘记关闭资源而导致的文件句柄泄漏。

避免文件句柄泄漏，推荐使用 try-with-resources

文件句柄泄漏是一个潜在的威胁，会导致资源耗尽和系统性能下降。try-with-resources 语句提供了一种简洁、安全且高效的方式来管理资源，可以有效地避免文件句柄泄漏。在编写 Java 代码时，应该养成使用 try-with-resources 语句的良好习惯。