Java Runtime.exec 子进程流管理：避免资源泄露与死锁

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
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 ProcessStreamManager {

    public static void main(String[] args) {
        // 示例：执行一个简单的命令，例如 'ls -l' (Linux/macOS) 或 'dir' (Windows)
        // 注意：根据操作系统调整命令
        String[] command;
        if (System.getProperty("os.name").toLowerCase().contains("win")) {
            command = new String[]{"cmd.exe", "/c", "dir"};
        } else {
            command = new String[]{"ls", "-l"};
        }

        Process process = null;
        ExecutorService executor = Executors.newFixedThreadPool(2); // 用于处理输出和错误流的线程池

        try {
            ProcessBuilder pb = new ProcessBuilder(command);
            process = pb.start();

            // 1. 处理标准输出流 (子进程的输出)
            // 使用 try-with-resources 确保 BufferedReader 和 InputStreamReader 被关闭
            Future<String> outputFuture = executor.submit(() -> {
                StringBuilder output = new StringBuilder();
                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 process output: " + e.getMessage());
                }
                return output.toString();
            });

            // 2. 处理标准错误流 (子进程的错误输出)
            Future<String> errorFuture = executor.submit(() -> {
                StringBuilder errorOutput = new StringBuilder();
                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 process error stream: " + e.getMessage());
                }
                return errorOutput.toString();
            });

            // 3. 处理标准输入流 (向子进程写入数据，如果需要的话)
            // 此示例中不需要向 'ls -l' 或 'dir' 写入，但如果需要，可以在这里使用 OutputStream
            try (OutputStream os = process.getOutputStream()) {
                // 例如：os.write("some input".getBytes());
                // os.flush();
            } catch (IOException e) {
                System.err.println("Error writing to process input: " + e.getMessage());
            }

            // 等待子进程执行完毕
            int exitCode = process.waitFor();
            System.out.println("Process exited with code: " + exitCode);

            // 获取并打印子进程的输出和错误
            System.out.println("\n--- Standard Output ---");
            System.out.println(outputFuture.get());

            System.out.println("\n--- Standard Error ---");
            System.out.println(errorFuture.get());

        } catch (IOException | InterruptedException | java.util.concurrent.ExecutionException e) {
            System.err.println("Failed to execute process: " + e.getMessage());
        } finally {
            // 确保线程池关闭
            executor.shutdown();
            try {
                if (!executor.awaitTermination(5, TimeUnit.SECONDS)) {
                    executor.shutdownNow();
                }
            } catch (InterruptedException ie) {
                executor.shutdownNow();
                Thread.currentThread().interrupt();
            }

            // 销毁进程，释放与进程相关的资源
            if (process != null) {
                process.destroy(); // 尝试终止子进程
                try {
                    process.waitFor(5, TimeUnit.SECONDS); // 等待子进程终止
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
                if (process.isAlive()) {
                    process.destroyForcibly(); // 如果仍未终止，则强制终止
                }
            }
        }
    }
}