Java Runtime.exec 返回的进程流：资源管理与最佳实践-java教程-PHP中文网

Java Runtime.exec 返回的进程流：资源管理与最佳实践

使用 `runtime.exec` 执行外部命令时，其返回的 `process` 对象所提供的输入/输出流（`getinputstream()`、`getoutputstream()`、`geterrorstream()`）必须被显式关闭。未能及时关闭这些流会导致系统资源泄露、子进程阻塞甚至死锁，严重影响应用程序的稳定性和性能。本文将详细阐述其原因并提供正确的处理方法。

引言：理解 Runtime.exec 与进程流

在 Java 应用程序中，Runtime.exec() 方法提供了一种执行外部系统命令或程序的机制。当一个外部程序通过 Runtime.exec() 启动时，Java 虚拟机（JVM）会创建一个 Process 对象来代表这个新启动的子进程。这个 Process 对象不仅允许我们控制子进程（如等待其完成），还提供了访问子进程标准输入、标准输出和标准错误流的接口：

Process.getOutputStream()：获取连接到子进程标准输入（stdin）的输出流。通过向此流写入数据，可以作为子进程的输入。
Process.getInputStream()：获取连接到子进程标准输出（stdout）的输入流。通过从此流读取数据，可以获取子进程的输出。
Process.getErrorStream()：获取连接到子进程标准错误（stderr）的输入流。通过从此流读取数据，可以获取子进程的错误输出。

这些流是 Java 进程与子进程之间进行通信的桥梁。然而，对这些流的管理不当是常见的错误源，可能导致难以诊断的资源泄露和程序挂起问题。

为何必须关闭进程流？

理解为何必须关闭这些流，关键在于认识到它们不仅仅是简单的 Java 对象，更是底层操作系统资源（如管道、文件句柄）的抽象。

1. 资源泄露风险

操作系统为每个进程可打开的文件句柄数量通常是有限制的。Process 对象关联的每个流都对应着一个或多个底层操作系统句柄。如果这些流在使用完毕后不被显式关闭，即使 Java 的垃圾回收器最终回收了 Process 对象，底层的操作系统句柄也可能不会立即释放。长期累积未关闭的句柄会导致文件句柄泄露，最终可能耗尽系统资源，使得后续的程序操作（如打开文件、创建套接字）失败，报告“Too many open files”错误。

立即学习“Java免费学习笔记（深入）”；

2. 阻塞与死锁问题

Oracle 官方文档明确指出：

“Because some native platforms only provide limited buffer size for standard input and output streams, failure to promptly write the input stream or read the output stream of the subprocess may cause the subprocess to block, and even deadlock.” 这意味着，操作系统为子进程的标准输入/输出流提供的缓冲区大小是有限的。如果子进程产生了大量输出（stdout 或 stderr），而父进程（Java 应用程序）没有及时从 getInputStream() 或 getErrorStream() 读取这些输出，那么子进程的输出缓冲区可能会被填满。一旦缓冲区满，子进程将阻塞，等待父进程读取数据以清空缓冲区。类似地，如果父进程向 getOutputStream() 写入数据，而子进程没有及时读取，子进程的输入缓冲区也可能被填满，导致父进程阻塞。更复杂的情况是，如果父进程在等待子进程完成（通过 process.waitFor()），而子进程又在等待父进程读取其输出（或提供输入），就会发生经典的死锁，导致整个应用程序挂起。

3. 子进程的生命周期

Process 对象被垃圾回收并不意味着子进程会终止。

“The subprocess is not killed when there are no more references to the Process object, but rather the subprocess continues executing asynchronously.” 子进程是独立于 Java 进程运行的。即使 Process 对象在 Java 堆中不再被引用，子进程仍可能继续执行。如果流未关闭，子进程的输出可能永远无法被消费，从而导致上述的阻塞和资源占用问题。正确关闭流是确保子进程能够顺利完成其任务并释放其资源的关键一步。

进程流的正确关闭方法

为了避免上述问题，必须在不再需要时显式关闭 Process 对象的所有相关流。

拾贝

一键同步微信读书所有笔记和划线，并在新标签页回顾

186

查看详情

1. 使用 try-with-resources (Java 7+)

对于 Java 7 及更高版本，try-with-resources 语句是管理流资源最推荐的方式，因为它能确保资源在块执行完毕后自动关闭，无论是否发生异常。然而，Process 对象本身并非 AutoCloseable，但其返回的流是。因此，我们通常需要手动获取这些流，并将其包装在 try-with-resources 块中。

示例代码：

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
import java.io.OutputStream;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;

public class ProcessStreamHandler {

    public static void main(String[] args) {
        // 假设要执行的命令，Windows下可以是 "cmd /c dir"，Linux/macOS下可以是 "ls -l"
        String[] command = {"ls", "-l"}; 
        // String[] command = {"cmd", "/c", "dir"}; // For Windows

        StringBuilder output = new StringBuilder();
        StringBuilder errorOutput = new StringBuilder();
        int exitCode = -1;

        Process process = null;
        ExecutorService executor = Executors.newFixedThreadPool(2); // 用于异步读取stdout和stderr

        try {
            // 1. 启动子进程
            process = Runtime.getRuntime().exec(command);

            // 2. 异步读取子进程的标准输出流
            Future<String> stdoutFuture = executor.submit(() -> {
                try (BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()))) {
                    String line;
                    while ((line = reader.readLine()) != null) {
                        output.append(line).append(System.lineSeparator());
                    }
                } catch (IOException e) {
                    System.err.println("Error reading stdout: " + e.getMessage());
                }
                return output.toString();
            });

            // 3. 异步读取子进程的标准错误流
            Future<String> stderrFuture = executor.submit(() -> {
                try (BufferedReader reader = new BufferedReader(new InputStreamReader(process.getErrorStream()))) {
                    String line;
                    while ((line = reader.readLine()) != null) {
                        errorOutput.append(line).append(System.lineSeparator());
                    }
                } catch (IOException e) {
                    System.err.println("Error reading stderr: " + e.getMessage());
                }
                return errorOutput.toString();
            });

            // 4. 如果需要向子进程写入数据，这里是示例
            // try (OutputStream os = process.getOutputStream()) {
            //     os.write("input to subprocess".getBytes());
            //     os.flush();
            // } catch (IOException e) {
            //     System.err.println("Error writing to stdin: " + e.getMessage());
            // }

            // 5. 等待子进程完成
            exitCode = process.waitFor();

            // 6. 获取异步读取的结果
            stdoutFuture.get(5, TimeUnit.SECONDS); // 等待结果，设置超时
            stderrFuture.get(5, TimeUnit.SECONDS);

        } catch (IOException e) {
            System.err.println("Error executing command: " + e.getMessage());
        } catch (InterruptedException e) {
            System.err.println("Process was interrupted: " + e.getMessage());
            Thread.currentThread().interrupt(); // 重新设置中断标志
        } catch (Exception e) { // Catch all other exceptions from Future.get()
            System.err.println("Error getting stream output: " + e.getMessage());
        } finally {
            // 7. 确保关闭所有流和销毁进程
            if (process != null) {
                // 显式关闭流，尽管try-with-resources会处理，但这里是兜底
                try {
                    process.getInputStream().close();
                } catch (IOException e) { /* ignore */ }
                try {
                    process.getOutputStream().close();
                } catch (IOException e) { /* ignore */ }
                try {
                    process.getErrorStream().close();
                } catch (IOException e) { /* ignore */ }

                // 销毁进程，确保其终止
                process.destroy(); 
            }
            // 8. 关闭线程池
            executor.shutdownNow();
            try {
                if (!executor.awaitTermination(5, TimeUnit.SECONDS)) {
                    System.err.println("Executor did not terminate in time.");
                }
            } catch (InterruptedException e) {
                System.err.println("Executor termination interrupted.");
                Thread.currentThread().interrupt();
            }
        }

        System.out.println("--- Command Output ---");
        System.out.println(output.toString());
        System.out.println("--- Error Output ---");
        System.out.println(errorOutput.toString());
        System.out.println("--- Exit Code ---");
        System.out.println(exitCode);
    }
}

登录后复制

代码解析：

异步读取： 为了避免死锁，标准输出和标准错误流通常需要被异步读取。这里使用了 ExecutorService 和 Future 来实现这一目标，确保父进程不会因为等待子进程输出而阻塞。
try-with-resources： 在异步读取的 Lambda 表达式内部，BufferedReader 和 InputStreamReader 被放置在 try-with-resources 块中，确保它们在读取完成后自动关闭。
process.waitFor()： 在确保所有输出流被消费的同时，等待子进程执行完毕。
finally 块： 即使 try-with-resources 已经处理了流，在 finally 块中显式地调用 close() 是一种额外的防御性编程措施，尤其是在复杂的场景中。更重要的是，process.destroy() 确保在所有操作完成后，如果子进程仍然存活，它会被强制终止。
线程池关闭： 确保用于异步读取的线程池被正确关闭，释放线程资源。

2. 传统 finally 块方法 (Java 6 及更早版本)

对于不支持 try-with-resources 的老版本 Java，必须在 finally 块中手动关闭所有流。

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
import java.io.OutputStream;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;

public class ProcessStreamHandlerLegacy {

    public static void main(String[] args) {
        String[] command = {"ls", "-l"}; // For Linux/macOS
        // String[] command = {"cmd", "/c", "dir"}; // For Windows

        StringBuilder output = new StringBuilder();
        StringBuilder errorOutput = new StringBuilder();
        int exitCode = -1;

        Process process = null;
        BufferedReader stdoutReader = null;
        BufferedReader stderrReader = null;
        OutputStream stdinWriter = null;
        ExecutorService executor = Executors.newFixedThreadPool(2);

        try {
            process = Runtime.getRuntime().exec(command);

            // 获取流
            stdoutReader = new BufferedReader(new InputStreamReader(process.getInputStream()));
            stderrReader = new BufferedReader(new InputStreamReader(process.getErrorStream()));
            stdinWriter = process.getOutputStream(); // 如果需要写入

            // 异步读取标准输出
            Future<String> stdoutFuture = executor.submit(() -> {
                String line;
                try {
                    while ((line = stdoutReader.readLine()) != null) {
                        output.append(line).append(System.lineSeparator());
                    }
                } catch (IOException e) {
                    System.err.println("Error reading stdout: " + e.getMessage());
                }
                return output.toString();
            });

            // 异步读取标准错误
            Future<String> stderrFuture = executor.submit(() -> {
                String line;
                try {
                    while ((line = stderrReader.readLine()) != null) {
                        errorOutput.append(line).append(System.lineSeparator());
                    }
                } catch (IOException e) {
                    System.err.println("Error reading stderr: " + e.getMessage());
                }
                return errorOutput.toString();
            });

            // 等待子进程完成
            exitCode = process.waitFor();

            // 获取异步读取的结果
            stdoutFuture.get(5, TimeUnit.SECONDS);
            stderrFuture.get(5, TimeUnit.SECONDS);

        } catch (IOException e) {
            System.err.println("Error executing command: " + e.getMessage());
        } catch (InterruptedException e) {
            System.err.println("Process was interrupted: " + e.getMessage());
            Thread.currentThread().interrupt();
        } catch (Exception e) {
            System.err.println("Error getting stream output: " + e.getMessage());
        } finally {
            // 确保关闭所有流
            try {
                if (stdoutReader != null) stdoutReader.close();
            } catch (IOException e) { /* ignore */ }
            try {
                if (stderrReader != null) stderrReader.close();
            } catch (IOException e) { /* ignore */ }
            try {
                if (stdinWriter != null) stdinWriter.close();
            } catch (IOException e) { /* ignore */ }

            // 销毁进程
            if (process != null) {
                process.destroy();
            }

            // 关闭线程池
            executor.shutdownNow();
            try {
                if (!executor.awaitTermination(5, TimeUnit.SECONDS)) {
                    System.err.println("Executor did not terminate in time.");
                }
            } catch (InterruptedException e) {
                System.err.println("Executor termination interrupted.");
                Thread.currentThread().interrupt();
            }
        }

        System.out.println("--- Command Output ---");
        System.out.println(output.toString());
        System.out.println("--- Error Output ---");
        System.out.println(errorOutput.toString());
        System.out.println("--- Exit Code ---");
        System.out.println(exitCode);
    }
}

登录后复制

重要注意事项与最佳实践

及时消费所有输出流： 这是避免死锁的关键。即使你不需要子进程的输出，也应该启动单独的线程或使用异步机制来持续读取 getInputStream() 和 getErrorStream()，直到它们到达文件末尾（EOF）。
处理错误流： getErrorStream() 同样重要。许多命令行工具会将错误信息输出到标准错误流，即使程序本身没有异常退出。消费错误流有助于诊断问题。
使用 ProcessBuilder： 尽管 Runtime.exec() 简单，但 ProcessBuilder 是更推荐的方式来创建和管理进程。它提供了更灵活的配置选项，例如设置工作目录、环境变量、重定向标准输入/输出等。ProcessBuilder 最终也是通过 Runtime.exec() 的底层机制来启动进程，但其封装性更好。
waitFor() 方法的陷阱： process.waitFor() 会阻塞当前线程，直到子进程终止。如果在调用 waitFor() 之前或期间没有正确处理子进程的输入/输出流，很可能导致死锁。因此，在调用 waitFor() 之前，务必启动独立的线程来消费子进程的输出流。
process.destroy()： 在程序结束或发生异常时，调用 process.destroy() 是一个好习惯，可以强制终止子进程，防止其成为僵尸进程或持续占用资源。