Java Process.onExit 怎样异步等待子进程结束

Java 用 ProcessBuilder.start() 启动外部程序后，最容易把“等待进程结束”和“读取进程结果”混成一件事。waitFor() 会让调用线程等待；Process.onExit() 则返回一个 CompletableFuture，可以把结束事件接入后续异步动作。实际项目中还要单独处理标准输出、标准错误、退出码和超时销毁。

官方参考地址：https://docs.oracle.com/en/java/javase/25/docs/api/java.base/java/lang/Process.html

本文只讨论单个子进程的异步收尾，不展开进程树终止。核心做法是：启动后立即安排输出读取，用 onExit() 监听终止，再在完成回调中读取退出码；如果超时，则显式调用 destroy() 或 destroyForcibly()。

waitFor 和 onExit 的差别在哪里

waitFor() 的语义很直白：当前线程在子进程结束前停住，并直接得到退出码。它适合命令行工具、短任务或本来就有专用等待线程的场景。onExit() 返回的是完成阶段，当前线程可以先去处理其他请求，结束后再触发依赖动作。

Oracle 文档明确说明，onExit() 返回的 future 会在进程终止时完成，不论退出状态是什么。因此“future 完成”只表示进程结束，不能直接当作成功；成功判断仍要读取 exitValue()，通常约定退出码 0 表示正常结束。

用 onExit 把退出码接入异步链

最小的异步收尾只需要把 Process 映射为退出码。thenApply 适合有返回值的转换；如果只是记录结果或发消息，则可以使用 thenAccept。需要切换到指定线程池时，再选择对应的 Async 变体。

import java.io.IOException;
import java.util.List;
import java.util.concurrent.CompletableFuture;

public final class AsyncProcessExit {
    public static CompletableFuture waitExit(List command)
            throws IOException {
        // 只负责启动进程，真正的结束通知交给 onExit。
        Process process = new ProcessBuilder(command).start();

        // onExit 完成表示进程已经终止，再读取退出码。
        return process.onExit().thenApply(done -> {
            // 这里不能把 future 完成直接当成业务成功。
            int code = done.exitValue();
            if (code != 0) {
                throw new IllegalStateException("子进程退出码：" + code);
            }
            return code;
        });
    }
}

这个方法仍可能抛出启动阶段的 IOException，而异步链中的异常会进入返回 future。调用方可以继续组合它，也可以在边界处用 whenComplete 记录最终状态。

输出流不能因为异步等待就放着不管

子进程的标准输出和标准错误通常通过父进程可访问的流暴露出来。官方 API 提醒，某些平台的管道缓冲区有限，如果没有及时读取，子进程可能阻塞甚至死锁。所以 onExit() 只解决“何时结束”的通知，不替代输出消费。

如果业务只需要合并后的日志，可以在启动时使用 redirectErrorStream(true)，再把合并后的标准输出交给独立读取任务。若必须区分 stdout 和 stderr，就分别读取两个 reader，并在结束后关闭它们。

import java.io.BufferedReader;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.stream.Collectors;

public final class ProcessOutputCollector {
    public static CompletableFuture collect() throws IOException {
        // 合并 stderr 只是示例选择；需要分级日志时应保留两条流。
        Process process = new ProcessBuilder("java", "-version")
                .redirectErrorStream(true)
                .start();
        ExecutorService readerPool = Executors.newCachedThreadPool();

        CompletableFuture output = CompletableFuture.supplyAsync(() -> {
            // reader 在任务结束时关闭，避免把文件描述符留给进程对象。
            try (BufferedReader reader =
                         process.inputReader(StandardCharsets.UTF_8)) {
                return reader.lines().collect(Collectors.joining("\n"));
            } catch (IOException e) {
                // 把读取异常转成异步链可以传播的异常。
                throw new CompletionException(e);
            }
        }, readerPool);

        return process.onExit()
                .thenCombine(output, (done, text) -> {
                    // 只有完成通知和输出都到达，结果才完整。
                    if (done.exitValue() != 0) {
                        throw new IllegalStateException("子进程执行失败");
                    }
                    return text;
                })
                .whenComplete((value, error) -> {
                    // 读取任务结束后释放自建线程池。
                    readerPool.shutdown();
                });
    }
}

这里的重点不是固定使用哪种线程池，而是把“读流”和“等退出”当成两个独立完成条件。生产代码还应限制输出大小，避免外部程序持续输出导致内存增长。

超时、取消和 destroy 不是同一个动作

CompletableFuture.orTimeout() 可以让等待链在超过预算后异常完成，但取消或超时 future 不会自动杀死底层进程。需要终止子进程时，必须保留 Process 引用并显式调用销毁方法。

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.TimeUnit;

public final class ProcessTimeout {
    public static CompletableFuture waitWithTimeout(Process process) {
        // 先建立退出码转换，再给等待链加时间预算。
        CompletableFuture exitCode =
                process.onExit().thenApply(done -> done.exitValue());

        return exitCode.orTimeout(30, TimeUnit.SECONDS)
                .whenComplete((code, error) -> {
                    // 超时只改变 future 状态，活着的进程仍需显式收尾。
                    if (error != null && process.isAlive()) {
                        process.destroy();
                    }
                });
    }
}

优先使用 destroy() 给进程一个正常终止机会；如果外部程序已经失去响应，再根据业务策略选择 destroyForcibly()。注意，强制销毁后进程也可能短暂保持存活，不能把调用返回瞬间当成资源已经全部释放。

按任务选择实现组合

常见问题

onExit() 完成后一定是成功吗？

不一定。它只表示进程已经终止，仍应读取 exitValue() 并按业务约定判断退出码。

取消 onExit() 的 CompletableFuture 会杀掉进程吗？

不会。取消 future 与控制操作系统进程是两件事，需要时显式调用 destroy() 或 destroyForcibly()。

为什么已经用了 onExit 还会卡住？

常见原因是没有消费标准输出或错误输出，子进程先把管道缓冲区写满。把流读取与退出等待分别安排，并在完成后关闭资源。

什么时候仍然适合 waitFor？

单线程命令行工具、短生命周期脚本或已经隔离了等待线程的简单任务可以继续使用 waitFor；面向请求的服务通常更适合把退出通知接入异步链。

总结一下：onExit() 解决的是异步获得“进程已终止”的信号，exitValue() 负责解释结果，输出流读取负责避免管道阻塞，超时处理负责主动销毁。把这四个职责分开，异步等待才不会变成只换了一种写法的阻塞。