Java Runtime.exec进程流管理：避免资源泄露与死锁的实践指南

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
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) {
        // 根据操作系统选择合适的命令
        String[] command;
        if (System.getProperty("os.name").toLowerCase().contains("windows")) {
            command = new String[]{"cmd.exe", "/c", "dir"}; // Windows
        } else {
            command = new String[]{"ls", "-l"}; // Unix/Linux/macOS
        }

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

        try {
            ProcessBuilder pb = new ProcessBuilder(command);
            pb.redirectErrorStream(false); // 确保标准输出和标准错误是独立的流
            process = pb.start();

            // 创建任务来异步读取标准输出流
            Future<StringBuilder> 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 standard output: " + e.getMessage());
                }
                return output;
            });

            // 创建任务来异步读取标准错误流
            Future<StringBuilder> 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 standard error: " + e.getMessage());
                }
                return errorOutput;
            });

            // 等待进程执行完成，并设置超时
            boolean finished = process.waitFor(10, TimeUnit.SECONDS);
            if (!finished) {
                System.err.println("Process timed out after 10 seconds.");
                process.destroyForcibly(); // 强制终止进程
            }

            // 获取异步读取的结果
            String stdout = outputFuture.get().toString();
            String stderr = errorFuture.get().toString();

            System.out.println("--- Standard Output ---");
            System.out.println(stdout.isEmpty() ? "(No standard output)" : stdout);

            System.out.println("--- Standard Error ---");
            System.out.println(stderr.isEmpty() ? "(No standard error)" : stderr);

            int exitCode = process.exitValue();
            System.out.println("Process exited with code: " + exitCode);

        } catch (IOException | InterruptedException | java.util.concurrent.ExecutionException e) {
            System.err.println("An error occurred during process execution: " + e.getMessage());
        } finally {
            // 确保关闭执行器
            executor.shutdown();
            try {
                if (!executor.awaitTermination(5, TimeUnit.SECONDS)) {
                    executor.shutdownNow(); // 如果无法优雅关闭，则强制关闭
                }
            } catch (InterruptedException e) {
                executor.shutdownNow();
                Thread.currentThread().interrupt();
            }
            // 不需要显式关闭 process.getInputStream() 和 process.getErrorStream()，
            // 因为它们已经在 try-with-resources 中处理，并且在进程结束后会自动关闭。
            // 但如果进程没有正常结束，或者有未消费的输出，确保流被关闭是好的实践。
            // 在此示例中，我们通过异步读取确保了流的消费。
        }
    }
}