解决链式进程中进程终止引发的IOException(Broken pipe)问题

问题核心是head -c 100进程终止后，后续写入操作因管道断裂抛出异常，同时上游的cat和base64进程仍在持续运行。要优雅处理这个情况，需要做到两点：监控终止进程并主动停止上游进程、捕获断管异常避免程序崩溃。

修改后的代码实现 #

import java.io.IOException;
import java.util.concurrent.Callable;

public class Main {
    public static void main(String[] args) throws IOException, InterruptedException {
        Process pa = new ProcessBuilder("cat", "/dev/random").start();
        Process pb = new ProcessBuilder("base64", "-w", "0").start();
        Process pc = new ProcessBuilder("head", "-c", "100").start();

        // 监控head进程，终止时主动关闭上游进程
        new Thread(() -> {
            try {
                pc.waitFor();
                // 优雅终止上游进程
                pa.destroy();
                pb.destroy();
                // 关闭输出流，让transferTo操作自然结束
                pb.getOutputStream().close();
                pc.getOutputStream().close();
            } catch (IOException | InterruptedException e) {
                // 忽略监控线程的异常
            }
        }).start();

        Thread ta = new Thread(uncheck(() -> {
            try {
                pa.getInputStream().transferTo(pb.getOutputStream());
            } catch (IOException e) {
                // 捕获断管异常，不抛出RuntimeException
                if (!"Broken pipe".equals(e.getMessage())) {
                    throw e;
                }
            }
        }));
        Thread tb = new Thread(uncheck(() -> {
            try {
                pb.getInputStream().transferTo(pc.getOutputStream());
            } catch (IOException e) {
                if (!"Broken pipe".equals(e.getMessage())) {
                    throw e;
                }
            }
        }));
        Thread tc = new Thread(uncheck(() -> pc.getInputStream().transferTo(System.out)));

        ta.start();
        tb.start();
        tc.start();
        ta.join();
        tb.join();
        tc.join();

        // 确保所有进程都终止
        pa.destroyForcibly();
        pb.destroyForcibly();
        pc.destroyForcibly();
    }

    public static Runnable uncheck(Callable<?> runnable) {
        return () -> {
            try {
                runnable.call();
            } catch (Exception e) {
                // 仅在非断管异常时抛出运行时异常
                if (!(e instanceof IOException && "Broken pipe".equals(e.getMessage()))) {
                    throw new RuntimeException(e);
                }
            }
        };
    }
}

关键修改点说明 #

• 监控head进程状态：新增线程等待pc（head进程）结束，一旦pc终止，立即调用destroy()终止上游的cat和base64进程，同时关闭相关输出流，让transferTo操作因流关闭而停止，避免后续写入触发断管异常。
• 捕获断管异常：在transferTo调用中，专门捕获Broken pipe异常并忽略（仅抛出其他类型IO异常），同时修改uncheck方法，不对断管异常包装成RuntimeException，避免程序因异常崩溃。
• 强制清理进程：所有线程结束后，调用destroyForcibly()确保所有子进程被彻底终止，防止残留进程。

这样修改后，当head进程结束时，上游进程会被优雅终止，断管异常不会输出到控制台，程序可以正常退出。

内容的提问来源于stack exchange，提问作者Plus