Windows下Java ProcessBuilder子进程日志文件无法删除及跨平台清理最佳实践

DevOps 小满

2026-7-8

跨平台进程与日志文件清理的最佳实践？

在Windows系统中，通过java.lang.ProcessBuilder创建子进程，当调用函数被中断后，清理子进程及其标准输出日志文件时出现错误："该进程无法访问文件，因为另一个进程正在使用它"。已确保先销毁子进程再删除日志文件，但问题依然存在。MacOS下测试无此问题，求跨平台的最佳实践。

Windows环境可复现示例

创建子进程的代码片段

public class UndeletableFileExample {
    public static void func() throws IOException {
        ProcessBuilder pb = null;
        Path stdout = null;
        Process p = null;
        long bufferTimeSecs = 30L;
        try {
            stdout = Files.createTempFile("example", ".log");
            pb = new ProcessBuilder("loop.cmd");
            pb.redirectErrorStream(true);
            pb.redirectOutput(stdout.toFile());
            p = pb.start();
            p.waitFor(bufferTimeSecs, TimeUnit.SECONDS);
            p.destroy();
            p.waitFor(bufferTimeSecs, TimeUnit.SECONDS);
            p.destroyForcibly();
            String out = Files.readString(stdout);
            int exitcode = p.exitValue();
            if(exitcode != 0) {
                throw new RuntimeException("Exited with code " + exitcode);
            }
            System.out.println(out);
        }
        catch(InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new RuntimeException("interrupted!");
        }
        finally {
            if(p != null) {
                p = p.destroyForcibly();
                while(p.isAlive()); // 这个循环是否有问题？
                System.out.println(p.exitValue());
            }
            if(stdout != null) {
                Files.delete(stdout);
            }
        }
    }
}

循环脚本`loop.cmd`内容

FOR /L %%i IN (1,1,100000) DO echo %%i

模拟中断的主程序代码

public class Demo {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread() {
            @Override
            public void run() {
                try {
                    UndeletableFileExample.func();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        };
        t.start();
        Thread.sleep(2000L);
        t.interrupt();
        t.join();
    }
}

MacOS测试情况

MacOS下使用以下循环脚本测试，线程中断后清理进程和日志文件无问题：

for i in `seq 1 1000000`; do echo $i; done

Windows下错误信息

Exception in thread "Thread-0" java.lang.RuntimeException: java.nio.file.FileSystemException: <...>\example1234.log: The process cannot access the file because it is being used by another process.

问题原因与跨平台解决方案

核心原因

Windows系统中，子进程被销毁后，其持有的文件句柄（包括日志文件的输出句柄）可能不会立即释放；而Linux/MacOS的文件系统允许删除被打开的文件，后续由系统自动回收资源，这是跨平台差异的根源。另外代码中while(p.isAlive())属于忙等待，不仅会占用过高CPU，也无法保证文件句柄已完全释放。

跨平台最佳实践

由Java接管子进程输出的读写
不要直接将子进程输出重定向到文件，改用Java读取子进程的输入流，再写入日志文件。这样Java完全控制文件句柄，中断时可主动关闭流，避免文件被子进程占用，跨平台行为一致。
示例修改：

stdout = Files.createTempFile("example", ".log");
pb = new ProcessBuilder("loop.cmd");
pb.redirectErrorStream(true);
p = pb.start();
// 用线程读取子进程输出并写入文件
try (InputStream in = p.getInputStream();
     OutputStream out = Files.newOutputStream(stdout, StandardOpenOption.CREATE)) {
    in.transferTo(out);
}

正确等待进程终止，替换忙等待
使用waitFor()替代while(p.isAlive())，设置超时时间并处理中断，避免无效的CPU占用：

if (p != null) {
    p.destroyForcibly();
    // 等待进程终止，设置超时
    boolean terminated = p.waitFor(10, TimeUnit.SECONDS);
    if (!terminated) {
        System.err.println("Process failed to terminate within timeout");
    }
}

延迟重试删除文件
如果必须使用文件重定向，在Windows下可尝试延迟重试删除，因为句柄释放可能存在延迟：

if (stdout != null) {
    int retryCount = 3;
    boolean deleted = false;
    while (retryCount-- > 0 && !deleted) {
        try {
            Files.delete(stdout);
            deleted = true;
        } catch (FileSystemException e) {
            try {
                Thread.sleep(500);
            } catch (InterruptedException ie) {
                Thread.currentThread().interrupt();
                break;
            }
        }
    }
    if (!deleted) {
        System.err.println("Failed to delete log file: " + stdout);
    }
}

启用临时文件自动删除机制
创建临时文件时设置DELETE_ON_CLOSE选项，即使删除失败，JVM退出时也会自动清理文件：

// 创建临时文件后，打开并设置关闭时删除
try (RandomAccessFile raf = new RandomAccessFile(stdout.toFile(), "rw")) {
    // 配合自行读写输出流的场景使用
}

完整优化后的代码示例

public class FixedUndeletableFileExample {
    public static void func() throws IOException {
        ProcessBuilder pb = null;
        Path stdout = null;
        Process p = null;
        long bufferTimeSecs = 30L;
        Thread outputReaderThread = null;
        try {
            stdout = Files.createTempFile("example", ".log");
            pb = new ProcessBuilder("loop.cmd");
            pb.redirectErrorStream(true);
            p = pb.start();

            // 启动线程读取子进程输出到文件
            outputReaderThread = new Thread(() -> {
                try (InputStream in = p.getInputStream();
                     OutputStream out = Files.newOutputStream(stdout, StandardOpenOption.CREATE, StandardOpenOption.WRITE)) {
                    in.transferTo(out);
                } catch (IOException e) {
                    System.err.println("Failed to read process output: " + e.getMessage());
                }
            });
            outputReaderThread.start();

            // 等待进程完成或超时
            boolean completed = p.waitFor(bufferTimeSecs, TimeUnit.SECONDS);
            if (!completed) {
                p.destroy();
                completed = p.waitFor(bufferTimeSecs, TimeUnit.SECONDS);
                if (!completed) {
                    p.destroyForcibly();
                }
            }

            // 等待输出读取线程完成
            if (outputReaderThread.isAlive()) {
                outputReaderThread.join(5000);
            }

            String out = Files.readString(stdout);
            int exitcode = p.exitValue();
            if (exitcode != 0) {
                throw new RuntimeException("Exited with code " + exitcode);
            }
            System.out.println(out);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            // 中断时先销毁进程
            if (p != null) {
                p.destroyForcibly();
            }
            // 中断输出读取线程
            if (outputReaderThread != null) {
                outputReaderThread.interrupt();
            }
            throw new RuntimeException("interrupted!");
        } finally {
            // 确保进程终止
            if (p != null) {
                p.destroyForcibly();
                try {
                    boolean terminated = p.waitFor(10, TimeUnit.SECONDS);
                    if (!terminated) {
                        System.err.println("Process did not terminate in time");
                    }
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
            // 删除日志文件，支持重试
            if (stdout != null) {
                int retries = 3;
                boolean deleted = false;
                while (retries-- > 0 && !deleted) {
                    try {
                        Files.delete(stdout);
                        deleted = true;
                    } catch (FileSystemException e) {
                        try {
                            Thread.sleep(500);
                        } catch (InterruptedException ie) {
                            Thread.currentThread().interrupt();
                            break;
                        }
                    } catch (IOException e) {
                        System.err.println("Failed to delete log file: " + e.getMessage());
                        break;
                    }
                }
                if (!deleted) {
                    System.err.println("Could not delete log file after retries: " + stdout);
                }
            }
        }
    }
}

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

Windows下Java ProcessBuilder子进程日志文件无法删除及跨平台清理最佳实践

Windows环境可复现示例 #

创建子进程的代码片段 #

循环脚本loop.cmd内容 #

模拟中断的主程序代码 #

MacOS测试情况 #

Windows下错误信息 #

问题原因与跨平台解决方案 #

核心原因 #

跨平台最佳实践 #

完整优化后的代码示例 #