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

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();
                }
            }
        }
    }
}