如何正确提前终止Java中通过ProcessBuilder创建的Process进程

• 输出缓冲区阻塞：场景2中未消费进程的stdout/stderr输出，Windows下缓冲区满后进程会卡在IO操作，无法响应销毁信号，导致残留
• Windows默认销毁逻辑缺陷：Java原生destroy()方法在Windows下对控制台类程序仅发送WM_CLOSE消息，大部分控制台程序不处理该消息，无法正常退出；且原生方法默认仅销毁直接启动的父进程，不会递归销毁其子进程
• 资源泄漏风险：原代码中错误流、输入流的关闭逻辑覆盖不全，也可能导致进程资源无法释放

核心修改点 #

1. 无论是否需要返回输出，都异步消费进程的所有输出流，避免缓冲区满阻塞进程
2. Windows平台下调用系统自带的taskkill命令强制销毁整个进程树，解决子进程残留问题
3. 全链路使用try-with-resources自动释放IO资源，避免资源泄漏

修改后代码示例 #

import java.io.*;
import java.util.List;
import java.util.concurrent.TimeUnit;

public class ProcessUtil {
    private static final boolean IS_WINDOWS = System.getProperty("os.name").toLowerCase().contains("win");

    public static String runCommand(List<String> commandList, boolean returnOutput) throws InterruptedException {
        ProcessBuilder pb = new ProcessBuilder(commandList);
        pb.redirectErrorStream(true);
        StringBuilder output = new StringBuilder();
        Process p = null;
        Thread outputConsumerThread = null;

        try {
            p = pb.start();
            final Process finalP = p;

            // 异步消费进程输出流，避免缓冲区阻塞
            outputConsumerThread = new Thread(() -> {
                try (BufferedReader reader = new BufferedReader(new InputStreamReader(finalP.getInputStream()))) {
                    String line;
                    while ((line = reader.readLine()) != null) {
                        if (returnOutput) {
                            output.append(line).append("\n");
                        }
                    }
                } catch (IOException e) {
                    // 进程销毁时流中断属于正常情况，可不打印异常
                }
            });
            outputConsumerThread.start();

            if (!returnOutput) {
                // 等待指定时长
                if (!p.waitFor(1, TimeUnit.MINUTES)) {
                    // 超时后强制销毁进程
                    killProcessTree(p);
                    // 等待销毁完成
                    if (!p.waitFor(20, TimeUnit.SECONDS)) {
                        p.destroyForcibly();
                    }
                }
                outputConsumerThread.join(5000);
                System.out.println(p.isAlive());
                return null;
            }

            // 需要返回输出的场景，等待消费线程读完所有输出
            outputConsumerThread.join();
            p.waitFor();

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 资源清理
            if (outputConsumerThread != null && outputConsumerThread.isAlive()) {
                outputConsumerThread.interrupt();
            }
            if (p != null) {
                try {
                    p.getInputStream().close();
                    p.getOutputStream().close();
                    p.getErrorStream().close();
                } catch (IOException e) {
                    // 忽略关闭异常
                }
            }
        }
        return output.toString();
    }

    /**
     * 销毁进程及其所有子进程，兼容Windows平台
     */
    private static void killProcessTree(Process p) {
        if (IS_WINDOWS) {
            try {
                long pid = getProcessPid(p);
                // 调用taskkill强制杀整个进程树：/F强制 /T杀子进程
                new ProcessBuilder("taskkill", "/F", "/T", "/PID", String.valueOf(pid))
                        .inheritIO()
                        .start()
                        .waitFor(5, TimeUnit.SECONDS);
            } catch (Exception e) {
                // 调用taskkill失败时 fallback到原生销毁逻辑
                p.destroy();
            }
        } else {
            // 非Windows平台直接使用原生销毁逻辑
            p.destroy();
        }
    }

    /**
     * 兼容Java 8/9+获取进程PID
     */
    private static long getProcessPid(Process p) throws Exception {
        // Java 9+ 直接调用pid方法
        try {
            return p.pid();
        } catch (NoSuchMethodError e) {
            // Java 8 反射获取pid
            if (p.getClass().getName().equals("java.lang.Win32Process") || p.getClass().getName().equals("java.lang.ProcessImpl")) {
                long handle = (long) p.getClass().getDeclaredField("handle").get(p);
                return (long) Class.forName("java.lang.ProcessHandleImpl").getDeclaredMethod("getProcessId", long.class).invoke(null, handle);
            }
            throw new UnsupportedOperationException("无法获取当前进程PID");
        }
    }
}

验证说明 #

修改后代码从根源解决了缓冲区阻塞问题，且Windows下通过taskkill强制销毁整个进程树，不会出现子进程残留的情况，任务管理器中不会再有遗留进程。

内容的提问来源于stack exchange，提问作者Apostolis I.