一个定时任务要调用外部的转换工具,把上传的文件转成 PDF。代码写成:启动进程、等它结束、读取输出、记录结果。本地测试文件很小,一切正常;上线之后,遇到大文件就卡住,日志停在 waitFor,子进程一直活着,父进程也一直等。
原因不在转换工具,在管道。子进程的标准输出默认接到一根管道上,管道有缓冲区;父进程不读,缓冲区写满,子进程写不进去就阻塞;子进程不结束,父进程的 waitFor 就永远不返回。两边互相等待,看起来像死锁,其实只是没有人去倒水。
这篇讲 Java 启动和管理外部进程的完整流程:命令怎么传、输出怎么接、什么时候算结束、退出码怎么看、进程怎么杀。多进程不是「调个命令行就完事」,它涉及两根管道、三个流、两个操作系统之间的约定。
先复现:不读输出,子进程会卡死
准备一个子进程,往标准输出写两万行文字。父进程启动它,设一个 3 秒的等待,期间不读任何输出:
ProcessBuilder pb = new ProcessBuilder("java", "-cp", ".", "PipeChild");
pb.redirectErrorStream(true);
Process p = pb.start();
boolean done = p.waitFor(3, TimeUnit.SECONDS);
System.out.println(done);
System.out.println(p.isAlive());
p.destroyForcibly();
p.waitFor();
System.out.println(p.exitValue());
javac -encoding UTF-8 JavaProcessDemo.java
java -Dstdout.encoding=UTF-8 -cp . JavaProcessDemo
3 秒内结束 : false
进程还活着 : true
强杀后退出码 : 1
三行输出说明了全部问题:三秒内没结束,进程还活着,强杀之后退出码是 1。子进程并不是算得慢,它早就写不动了。管道的缓冲区容量有限,父进程不读,写满之后 System.out.println 就阻塞在写操作上,子进程永远走不到结束。
这个现象和「子进程真的在跑很久」很难区分,因为从父进程看,两种情况下 waitFor 都不返回。区别在于 CPU 占用:真在计算时子进程占 CPU,卡在写管道时几乎不占。任务管理器里看一眼就能分辨,但线上往往没有这个条件。
图上这条「父进程读取或忽略」是关键。忽略不是「不处理」,而是让数据留在管道里,直到缓冲区满。Java 提供了几种明确的方式来接输出,选对了就不会卡。父进程和子进程在操作系统里是两个独立的进程,创建、调度和回收的细节见 操作系统:进程。
启动:命令和参数必须分开传
ProcessBuilder 的构造器接收一个字符串列表,第一个是可执行文件,后面是参数。它不会像 shell 那样解析一整条命令字符串,也不会处理引号、通配符、管道符。想执行 echo a b,要写成 new ProcessBuilder("cmd", "/c", "echo", "a", "b"),而不是一整串。
这样设计是有意为之:参数分开传,避免了拼接字符串带来的注入问题。用户输入作为某个参数传进去,不会被当成命令的一部分执行。反过来,如果你自己把用户输入拼进一条命令字符串再交给 shell,注入风险就回来了。原则是:能用参数列表就不要经过 shell。
工作目录也由 ProcessBuilder 控制。directory(File) 指定子进程的当前目录,不指定就继承父进程的当前目录。这一点很容易踩坑:父进程在 A 目录启动,子进程用相对路径找文件,结果找的是 A 目录下的文件,不是你以为的项目目录。本机测试时就遇到过——父进程从项目目录启动,子进程的 -cp . 指向了项目目录,类根本找不到,输出只有一行错误,看起来像「子进程没干活」。
环境变量用 environment() 拿到的是一个可修改的 Map,改完再 start 才生效。注意它是复制自父进程的环境,不是共享的;在子进程里改环境不会影响父进程。需要传递配置时,环境变量和命令行参数都可以,前者适合敏感信息(不会出现在进程列表里),后者适合显式配置。
可执行文件的查找依赖 PATH。写 "java" 而不写绝对路径时,系统会按当前环境的 PATH 去找,找到哪个版本就用哪个版本。生产环境里这很危险:同一台机器上装了多个 JDK,父进程启动时用的和子进程找到的可能不是同一个。要求确定性时,用绝对路径,或者在启动前打印 pb.command() 和实际解析结果。
接输出:重定向、合并与继承
处理子进程输出有四种常见方式,各有适用场景:
redirectOutput(Redirect.INHERIT):子进程直接写父进程的控制台,不经过 Java 的管道。不会卡,但父进程拿不到内容。redirectOutput(File):子进程直接写文件,由操作系统负责,不经过 Java 的管道。适合日志量大、只需要留档的场景。redirectOutput(Redirect.DISCARD):直接丢弃,适合只关心退出码、不关心输出的场景。这是最省事也最安全的默认选择之一。- 默认的管道:父进程通过
getInputStream读。灵活,但必须读,而且要考虑 stderr。
把输出重定向到文件之后,同样的子进程三秒内就能结束:
File out = File.createTempFile("pipechild", ".log");
pb.redirectOutput(out);
Process p = pb.start();
boolean ok = p.waitFor(5, TimeUnit.SECONDS);
System.out.println(ok);
System.out.println(out.length());
重定向到文件后结束 : true
输出文件字节数 : 768890
输出文件接近 750KB,子进程没有卡住,因为数据直接落到了磁盘,不经过那根容量有限的管道。注意 redirectErrorStream(true) 只是把 stderr 合并进 stdout,合并之后仍然走你选择的目标:走管道就还是要读,走文件就还是写文件。
重定向到文件或丢弃
由操作系统直接写入,父进程不需要参与,天然不会因为缓冲区满而卡死。适合批处理、日志留档、只关心成功失败的调用。代价是父进程拿不到实时输出,排查失败原因时要回头翻文件。
通过管道读取
父进程能实时处理每一行,可以做进度解析、关键字告警。代价是必须持续读,读得慢或忘记读都会让子进程阻塞;stderr 也要一并处理,否则它单独把缓冲区写满。
如果确实要读管道,最稳的做法是单独开一个线程读 stdout、另一个读 stderr(或者先合并),主线程只负责 waitFor。不要先 waitFor 再读,因为子进程可能正卡在写上,永远等不到结束。输出量不大时,也可以先 readAllBytes 把流读到结尾,再 waitFor;readAllBytes 会一直读到子进程关闭输出,读完之后子进程才能顺利退出。
读线程里要注意字符集。子进程的输出编码由它自己决定,父进程按什么编码解码要显式指定,否则中文可能变成问号。本机运行 Java 子进程时加了 -Dstdout.encoding=UTF-8,父进程读流时也用 UTF-8,两边才对得上。跨语言调用时,最稳的约定是「双方都用 UTF-8」,并在接口文档里写清楚。
结束与退出码:0 不总是成功
waitFor() 会一直等到子进程终止;waitFor(timeout, unit) 最多等指定时间,返回一个布尔值表示是否在期限内结束。它不会自动杀掉子进程,返回 false 之后子进程还在跑,必须自己调 destroy 或 destroyForcibly。
退出码通过 exitValue() 读取,但只能在进程结束后调用,否则抛 IllegalThreadStateException。惯例是 0 表示成功,非 0 表示失败,但「非 0 的具体含义」由子进程自己决定,没有统一标准。有的工具用 1 表示一般错误、2 表示参数错误,有的工具全用 1。判断成功与否,最好以文档为准,不要自己猜。
本机实测 cmd /c exit 3 得到的退出码是 3,说明退出码会原样传回。而被 destroyForcibly 杀掉的进程,退出码是 1,不是 Unix 上常见的 143(128 加 SIGTERM 的编号),也不是 137。这是平台差异,跨平台脚本不能依赖具体的终止码。
destroy() 在 Unix 上发送终止信号,在 Windows 上调用系统的终止接口;destroyForcibly() 更强制,给子进程留下的清理机会更少。两者都只作用于直接子进程,不会自动杀掉它派生的孙进程。一个 shell 脚本启动了三个后台任务,你杀掉 shell,三个任务可能还在跑,继续占着端口和文件。
要杀整棵进程树,用 ProcessHandle:p.toHandle().descendants().forEach(ProcessHandle::destroyForcibly),再处理自己。顺序上先杀后代再杀父,避免父进程先退出导致后代被系统收养、关系丢失。这个操作不是原子的,新派生的进程可能漏掉,关键场景要配合进程组或容器级别的管理。
除了阻塞等待,还可以用 p.onExit() 拿到一个 CompletableFuture<Process>,在进程结束时回调。它适合「启动之后先做别的事,结束再处理结果」的流程,不需要单独占一个线程等。回调里读退出码、清理临时文件都可以,但不要在回调里做长时间阻塞,否则会拖住完成线程。
ProcessHandle 还能查 pid、父进程、启动时间、命令行和 CPU 时间。排查「这个进程是谁启动的」「为什么有两个同名进程」时,这些信息比日志更直接。注意 info() 里的命令行在某些平台上可能被截断或拿不到,不要把它当成唯一依据。
Windows 与 Unix:那些不能照搬的习惯
第一,Windows 上没有 shebang,也没有内置的 shell 命令语义。要执行一条 shell 命令,必须显式启动 cmd 或 PowerShell,并把命令作为它的参数。直接传一个带空格的长字符串,系统会把它当成一个可执行文件名,找不到就报「系统找不到指定的文件」。
第二,路径和引号规则不同。Windows 的反斜杠在参数里可能被转义,含空格的路径需要引号,而引号本身又会被 ProcessBuilder 再处理一次。最稳妥的做法是尽量避免把复杂命令交给 shell,直接调用目标程序,参数分开传。
第三,终止信号不同。Unix 有 SIGTERM、SIGKILL,进程可以捕获前者做清理;Windows 的终止更直接,很多程序没有机会执行清理逻辑。需要优雅退出时,不能只靠 destroy,要设计一个「请求停止」的机制,比如写一个停止文件、发一个特定的请求,等对方自己退出,超时再强杀。
第四,进程和作业的控制方式不同。Unix 有进程组、会话、作业控制;Windows 有作业对象,但 Java 的标准 API 没有直接暴露。跨平台的代码不要把某一侧的概念当成通用能力。
还有命令本身的差异。同一个「打印一段文字」的需求,Windows 上可能是 cmd 加 /c 加 echo,Unix 上是 /bin/sh 加 -c 加 echo,参数个数和引号规则都不一样。把这些差异写在一个平台适配层里,业务代码只调用「运行转换工具」这样的抽象方法,比在几十个地方判断操作系统要可靠。
出问题时先看哪里
| 现象 | 真实原因 | 第一步查什么 |
|---|---|---|
waitFor 一直不返回,子进程还在 | stdout 或 stderr 管道写满,子进程阻塞在写操作 | 看有没有读输出;改成重定向到文件、丢弃或单独线程读取 |
| 子进程输出一行都没有 | 输出走了管道但没被读,或者被重定向到了别处 | 检查 redirectOutput 的设置;确认读的是 getInputStream 不是别的流 |
| 退出码非 0,但看不到错误原因 | stderr 没有合并也没有读取,错误信息丢了 | 加 redirectErrorStream(true);或把 stderr 重定向到文件 |
| 子进程报「找不到类」或「找不到文件」 | 工作目录或相对路径不对,继承的是父进程的当前目录 | 打印 pb.directory() 和子进程实际路径;显式设置工作目录 |
| Windows 报「系统找不到指定的文件」 | 把整条命令当成一个可执行文件名,或路径里有空格没处理 | 确认第一个参数是可执行文件;命令和参数分开传 |
| 杀掉父进程后端口还被占用 | 只杀了直接子进程,孙进程还在跑 | 用 ProcessHandle.descendants() 查看;先杀后代再杀父 |
exitValue 抛 IllegalThreadStateException | 进程还没结束就读取退出码 | 先 waitFor 并确认返回 true,再读退出码 |
| 子进程输出中文乱码 | 子进程的输出编码和父进程解码方式不一致 | 统一用 UTF-8 启动参数;读流时显式指定字符集 |
| 父进程退出后子进程仍在运行 | 没有在关闭钩子里清理,或子进程自己脱离了父子关系 | 注册 shutdown hook;记录 pid 并做兜底清理 |
排查多进程问题,先分清是「启动失败」「运行卡住」还是「退出异常」。启动失败看异常和路径,运行卡住看管道和工作目录,退出异常看退出码和 stderr。三类问题的日志位置和排查手段都不一样。
边界与代价
用外部进程能复用成熟工具,也能把不同语言拼在一起,但它的代价不小:
- 启动成本高:每次
start都要创建操作系统进程,JVM 类程序还要额外启动一个 JVM。小任务频繁起进程,开销可能比任务本身还大。 - 通信靠文本:父子之间只有字节流,没有类型、没有对象、没有事务。需要结构化数据就得自己定格式、自己解析、自己处理错误。
- 生命周期不受控:子进程可能自己退出、可能卡住、可能派生后代。父进程必须假设「对方随时可能不听话」,超时、清理、兜底都要有。
- 平台差异多:命令、路径、引号、信号、退出码、文件锁,每一项都可能在换系统后失效。跨平台代码要把这些差异集中封装,不要散落在业务里。
- 安全边界:拼接用户输入再交给 shell,等于把命令执行权交出去。能不用 shell 就不用,必须用时做严格白名单。
- 不适合做服务编排:进程崩溃不会自动重启,日志不会自动轮转,资源不会自动隔离。这些是容器编排或守护进程的职责,不是
ProcessBuilder的。 - Unix 上的僵尸进程要处理:子进程结束后父进程没有回收,会留下一个占用进程表项的空壳。Java 的
waitFor会完成回收,但如果你只启动不等待,长期运行的服务可能积累大量僵尸进程,最终无法创建新进程。
还有一个隐性成本:调试。子进程的异常不会出现在父进程的堆栈里,只能通过退出码和 stderr 推断。给每个子进程带上足够的上下文(命令、参数、工作目录、pid),出问题时才不用靠猜。
当天能自己验证的练习
- 写一个输出两万行的子进程,父进程只
waitFor(3, SECONDS)不读输出,确认返回 false、进程仍活着;再destroyForcibly并打印退出码。 - 把同一个子进程的输出重定向到临时文件,再次等待,确认能正常结束,并打印文件字节数,对比两种方式的差别。
- 用
new ProcessBuilder("cmd", "/c", "exit", "3")启动一个进程,打印waitFor()的返回值,确认退出码原样传回。 - 给子进程显式设置
directory,分别用相对路径和绝对路径启动同一个程序,观察「找不到类」或「找不到文件」的变化。 - 启动一个会派生后代的进程,打印
p.pid()和p.toHandle().descendants().count(),只 destroy 父进程后再数一次,确认后代是否还在。
小结
三句话收一下:ProcessBuilder 的命令和参数要分开传,工作目录默认继承父进程;子进程的输出管道不读会写满,导致子进程阻塞、waitFor 永不返回,重定向到文件、丢弃或单独线程读取都能避免;退出码 0 通常表示成功,destroy 只杀直接子进程,杀整棵树要用 ProcessHandle.descendants()。
下一篇讲多线程。多进程之间靠管道和退出码通信,多线程之间靠共享内存和锁通信;今天遇到的「两边互相等待」在下一篇会以死锁的形式出现,而「等待要有超时」这条经验同样适用。