文件已经加锁，为什么同一程序换个通道还会抛异常？

import java.io.IOException;
import java.nio.channels.FileChannel;
import java.nio.channels.FileLock;
import java.nio.channels.OverlappingFileLockException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardOpenOption;
import java.util.Comparator;
import java.util.Locale;
import java.util.concurrent.TimeUnit;

/** Only locks a newly-created temporary file; never accepts a user file. */
public class FileLockScopeDemo {
    private static int checks;

    private static void check(boolean condition, String message) {
        if (!condition) throw new AssertionError(message);
        checks++;
    }

    private static boolean overlaps(FileChannel channel) throws IOException {
        try (FileLock unexpected = channel.tryLock(0, 16, false)) {
            return false;
        } catch (OverlappingFileLockException expected) {
            return true;
        }
    }

    private static String child(Path directory, Path file, String label) throws Exception {
        boolean windows = System.getProperty("os.name").toLowerCase(Locale.ROOT).contains("win");
        // javaw is the no-console Windows launcher. Output goes to our temporary file.
        Path java = Path.of(System.getProperty("java.home"), "bin", windows ? "javaw.exe" : "java");
        Path output = directory.resolve(label + ".out");
        Process process = new ProcessBuilder(java.toString(), "-cp", System.getProperty("java.class.path"),
                FileLockScopeDemo.class.getName(), "--child", file.toString())
                .redirectErrorStream(true).redirectOutput(output.toFile()).start();
        try {
            process.getOutputStream().close();
            if (!process.waitFor(5, TimeUnit.SECONDS)) throw new IOException("child deadline");
            String result = Files.readString(output).strip();
            check(process.exitValue() == 0, "child failed: " + result);
            return result;
        } finally {
            if (process.isAlive()) {
                process.destroyForcibly();
                if (!process.waitFor(5, TimeUnit.SECONDS)) throw new IOException("child not reaped");
            }
            process.getInputStream().close();
            process.getErrorStream().close();
            process.getOutputStream().close();
        }
    }

    private static void removeOwnedDirectory(Path directory) throws IOException {
        try (var paths = Files.walk(directory)) {
            for (Path path : paths.sorted(Comparator.reverseOrder()).toList()) Files.delete(path);
        }
    }

    public static void main(String[] args) throws Exception {
        if (args.length == 2 && args[0].equals("--child")) {
            // This branch is invoked only by the parent with its own temporary file.
            try (FileChannel channel = FileChannel.open(Path.of(args[1]), StandardOpenOption.WRITE);
                 FileLock lock = channel.tryLock(0, 16, false)) {
                System.out.println(lock == null ? "other_jvm=null" : "other_jvm=acquired");
            }
            return;
        }
        if (args.length != 0) throw new IllegalArgumentException("run without arguments");
        Path directory = Files.createTempDirectory("qinghuan-filelock-");
        try {
            Path file = directory.resolve("owned.bin");
            Files.write(file, new byte[16]);
            // Keep BOTH channels open until after the held lock is released.
            try (FileChannel first = FileChannel.open(file, StandardOpenOption.WRITE);
                 FileChannel second = FileChannel.open(file, StandardOpenOption.WRITE)) {
                try (FileLock held = first.lock(0, 16, false)) {
                    check(overlaps(first), "same channel must reject overlap");
                    check(overlaps(second), "another channel in same JVM must reject overlap");
                    check(held.isValid(), "original lock still held");
                    check(child(directory, file, "held").equals("other_jvm=null"), "child must see contention");
                    System.out.println("same_channel=OverlappingFileLockException; same_jvm_other_channel=OverlappingFileLockException");
                    System.out.println("while_parent_holds: other_jvm=null");
                }
                check(child(directory, file, "released").equals("other_jvm=acquired"), "released lock must be available");
                System.out.println("after_parent_release: other_jvm=acquired");
            }
        } finally {
            removeOwnedDirectory(directory);
        }
        check(!Files.exists(directory), "temporary directory removed");
        System.out.println("PASS checks=" + checks + "; children_reaped=true; temporary_files_cleaned=true");
    }
}