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 ProcessStreamManagement {

    public static void main(String[] args) {
        // 根据操作系统选择不同的命令
        String os = System.getProperty("os.name").toLowerCase();
        String[] command;
        if (os.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 builder = new ProcessBuilder(command);
            // 可以设置工作目录、环境变量等
            // builder.directory(new File("/path/to/workdir"));

            process = builder.start();

            // 提交任务以并发读取标准输出和标准错误流
            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();
            });

            Future<String> errorFuture = executor.submit(() -> {
                StringBuilder error = new StringBuilder();
                try (BufferedReader reader = new BufferedReader(new InputStreamReader(process.getErrorStream()))) {
                    String line;
                    while ((line = reader.readLine()) != null) {
                        error.append(line).append(System.lineSeparator());
                    }
                } catch (IOException e) {
                    System.err.println("Error reading process error stream: " + e.getMessage());
                }
                return error.toString();
            });

            // 如果需要向子进程写入数据，可以使用getOutputStream()
            // try (OutputStream os = process.getOutputStream()) {
            //     os.write("input for subprocess".getBytes());
            //     os.flush();
            // }

            // 等待子进程执行完毕，并获取退出码
            int exitCode = process.waitFor();
            System.out.println("Command exited with code: " + exitCode);

            // 获取并发读取的结果
            String outputResult = outputFuture.get();
            String errorResult = errorFuture.get();

            System.out.println("\n--- Standard Output ---");
            System.out.println(outputResult);

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

        } catch (IOException | InterruptedException | java.util.concurrent.ExecutionException e) {
            System.err.println("Failed to execute command: " + e.getMessage());
            Thread.currentThread().interrupt(); // 重新设置中断状态
        } finally {
            // 确保线程池关闭
            executor.shutdown();
            try {
                if (!executor.awaitTermination(5, TimeUnit.SECONDS)) {
                    executor.shutdownNow(); // 强制关闭
                }
            } catch (InterruptedException e) {
                executor.shutdownNow();
                Thread.currentThread().interrupt();
            }

            // 显式销毁进程，以防其仍在运行（例如，如果父进程在waitFor()之前中断）
            if (process != null) {
                process.destroy();
                // 也可以使用 destroyForcibly() 来强制终止
            }
        }
    }
}