使用 `runtime.exec` 或 `processbuilder` 启动外部进程时，必须显式关闭从 `process` 对象获取的输入、输出和错误流。未能及时关闭这些流可能导致操作系统层面资源泄露，并因底层缓冲区溢出而引发子进程阻塞甚至死锁，严重影响应用程序的稳定性和性能。
Runtime.exec 与进程通信概述
在 Java 应用程序中，Runtime.exec() 方法或更推荐的 ProcessBuilder 类用于启动外部操作系统进程。当一个外部进程被启动后，Java 应用程序可以通过 Process 对象与该进程进行通信。Process 对象提供了三个关键的流：
- getInputStream(): 获取子进程的标准输出流，Java 程序通过此流读取子进程的输出。
- getOutputStream(): 获取子进程的标准输入流，Java 程序通过此流向子进程写入数据。
- getErrorStream(): 获取子进程的标准错误流，Java 程序通过此流读取子进程的错误输出。
这些流是 Java 进程与外部进程之间进行数据交换的桥梁。理解并正确管理这些流对于确保应用程序的健壮性至关重要。
为何必须关闭流：资源泄露与死锁风险
许多开发者可能会误以为这些流会随着 Process 对象的垃圾回收而自动关闭，或者在子进程结束时自动关闭。然而，事实并非如此。Java 虚拟机不会自动关闭这些由底层操作系统资源支持的流。
根据官方文档的明确指出：
立即学习“Java免费学习笔记（深入）”；
- 有限的缓冲区大小： 某些原生平台为标准输入和输出流提供有限的缓冲区大小。这意味着如果父进程未能及时写入子进程的输入流，或未能及时读取子进程的输出流，这些缓冲区可能会被填满。
- 子进程阻塞与死锁： 当缓冲区被填满时，子进程可能会被阻塞，等待父进程消费或提供数据。如果父进程也在等待子进程完成（例如通过 process.waitFor()），而子进程又在等待父进程处理流，就可能导致经典的死锁情况。
- 资源泄露： 未关闭的流会持续占用操作系统资源（如文件描述符或句柄）。长时间运行的应用程序如果反复启动进程而不关闭流，将导致这些资源逐渐耗尽，最终可能引发 OutOfMemoryError 或其他与资源相关的错误。
- 进程异步执行： 子进程在启动后会异步执行。即使 Java 应用程序中不再有对 Process 对象的引用，子进程也不会因此被终止，它会继续执行。因此，即使 Java Process 对象被垃圾回收，其关联的底层流资源也可能不会被释放。
因此，为了避免资源泄露和潜在的死锁问题，显式关闭这些流是强制性的最佳实践。
流关闭的最佳实践
处理 Runtime.exec 或 ProcessBuilder 启动的进程流时，应遵循以下步骤和最佳实践：
分析 Java Spring Boot 后端 Controller 代码，自动生成 Markdown 格式的接口文档。当用户说“生成 Java 接口文档”、“生成 API 文档”、“从 Spring 代码生成文档”时触发。
1. 获取并处理所有流
无论子进程是否实际产生输出或错误，都应该获取并处理其 InputStream 和 ErrorStream。即使你不需要读取这些内容，也至少应该启动一个单独的线程来消费这些流，以防止缓冲区被填满导致子进程阻塞。对于 OutputStream，如果你不需要向子进程提供输入，可以不写入，但仍然需要处理其关闭。
2. 使用 try-with-resources 语句
Java 7 引入的 try-with-resources 语句是管理可关闭资源（如流）的最佳方式。它能确保在 try 块结束时，无论正常退出还是发生异常，所有声明的资源都会被自动关闭。
import java.io.*;
import java.util.concurrent.*;
public class ProcessStreamHandler {
public static void main(String[] args) {
Process process = null;
try {
// 示例：执行一个简单的命令
// 对于 Windows: cmd.exe /c dir
// 对于 Linux/macOS: ls -l
String osName = System.getProperty("os.name").toLowerCase();
ProcessBuilder pb;
if (osName.contains("win")) {
pb = new ProcessBuilder("cmd.exe", "/c", "dir");
} else {
pb = new ProcessBuilder("ls", "-l");
}
process = pb.start();
// 创建线程来异步消费标准输出流和标准错误流，防止阻塞
ExecutorService executor = Executors.newFixedThreadPool(2);
Future<Void> outputFuture = executor.submit(() -> {
try (BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()))) {
String line;
System.out.println("--- Process Standard Output ---");
while ((line = reader.readLine()) != null) {
System.out.println(line);
}
} catch (IOException e) {
System.err.println("Error reading standard output: " + e.getMessage());
}
return null;
});
Future<Void> errorFuture = executor.submit(() -> {
try (BufferedReader errorReader = new BufferedReader(new InputStreamReader(process.getErrorStream()))) {
String line;
System.err.println("--- Process Standard Error ---");
while ((line = errorReader.readLine()) != null) {
System.err.println(line);
}
} catch (IOException e) {
System.err.println("Error reading standard error: " + e.getMessage());
}
return null;
});
// 如果需要向子进程写入数据，可以在这里获取 OutputStream 并使用 try-with-resources
// try (BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(process.getOutputStream()))) {
// writer.write("input to subprocess\n");
// writer.flush();
// } catch (IOException e) {
// System.err.println("Error writing to standard input: " + e.getMessage());
// }
// 等待子进程完成
int exitCode = process.waitFor();
System.out.println("Process exited with code: " + exitCode);
// 等待流处理线程完成
outputFuture.get();
errorFuture.get();
executor.shutdown(); // 关闭线程池
executor.awaitTermination(5, TimeUnit.SECONDS); // 等待线程池终止
} catch (IOException | InterruptedException | ExecutionException e) {
e.printStackTrace();
} finally {
// 确保进程被销毁，以防其仍在运行
if (process != null) {
process.destroy();
// 强制销毁后，可以等待一段时间确保进程完全退出
try {
process.waitFor(5, TimeUnit.SECONDS);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
}
}
}在上述示例中：
- 我们使用 ProcessBuilder 来启动进程，这比 Runtime.exec 更灵活和安全。
- 通过 ExecutorService 启动单独的线程来并发读取 getInputStream() 和 getErrorStream()，这是避免死锁的关键策略。
- 每个流的读取都封装在 try-with-resources 块中，确保 BufferedReader 和底层流在读取完成后自动关闭。
- process.waitFor() 用于等待子进程执行完成并获取其退出码。
- finally 块中调用 process.destroy() 是一个重要的清理步骤，即使子进程在 waitFor() 之前或之后因为某种原因未能正常退出，destroy() 也能强制终止它，防止僵尸进程。
3. 等待进程完成与销毁
在处理完所有流之后，使用 process.waitFor() 等待子进程终止。这会阻塞当前线程直到子进程退出。获取到退出码后，你可以根据需要进行进一步处理。
即使调用了 waitFor()，也强烈建议在 finally 块中调用 process.destroy()。destroy() 方法会强制终止子进程。这是一种防御性编程措施，以防子进程未能正常退出，成为僵尸进程，继续占用系统资源。对于长时间运行或可能无响应的进程，destroyForcibly() 提供了更强的终止保证。
注意事项与总结
- 始终显式关闭流： 这是最核心的原则。使用 try-with-resources 是最佳实践。
- 并发读取流： 如果子进程可能同时产生标准输出和标准错误，或者输出量较大，务必使用单独的线程（或 CompletableFuture 等异步机制）来并发读取 getInputStream() 和 getErrorStream()，以避免死锁。
- 处理 OutputStream： 如果你需要向子进程写入数据，也要将其封装在 try-with-resources 中，并在写入完成后及时关闭（或 flush()），以便子进程能够接收到输入并继续执行。
- 错误处理： 捕获 IOException 和 InterruptedException。前者可能在流操作时发生，后者可能在 waitFor() 或线程等待时发生。
- 进程销毁： 无论子进程是否正常完成，在 finally 块中调用 process.destroy() 都是一个良好的习惯，以确保所有相关资源被释放，避免僵尸进程。
正确管理 Runtime.exec 或 ProcessBuilder 产生的进程流是 Java 应用程序与外部进程交互时不可或缺的一部分。遵循上述指导原则，可以有效预防资源泄露、死锁等常见问题，从而构建更稳定、更健壮的系统。
