两个程序都确认文件不存在，为什么最后仍覆盖了对方？

"""Real two-process file creation in a private temporary directory."""
import json
import multiprocessing as mp
import os
import sys
import tempfile
import time
from pathlib import Path


def worker(name, filename, mode, connection):
    path = Path(filename)
    try:
        connection.send({"stage": "checked", "exists": path.exists()})
        if connection.recv() != "create":
            raise ValueError("unknown command")
        try:
            with path.open(mode, encoding="ascii") as stream:
                stream.write(name)
            result = "created_or_written"
        except FileExistsError:
            result = "already_exists"
        connection.send({"stage": "finished", "name": name, "result": result})
    finally:
        connection.close()


def receive(connection, deadline):
    remaining = deadline - time.monotonic()
    if remaining <= 0 or not connection.poll(remaining):
        raise TimeoutError("child did not report before the shared deadline")
    return connection.recv()


def run_round(folder, label, mode, order):
    # order=None releases both children without prescribing the winning process.
    context = mp.get_context("spawn")
    path = Path(folder) / (label + ".txt")
    processes, parents = {}, {}
    deadline = time.monotonic() + 8
    try:
        for name in ("A", "B"):
            parent, child = context.Pipe()
            process = context.Process(target=worker, args=(name, str(path), mode, child))
            parents[name], processes[name] = parent, process
            try:
                process.start()
            finally:
                child.close()
        checked = {name: receive(parents[name], deadline) for name in ("A", "B")}
        if not all(item == {"stage": "checked", "exists": False} for item in checked.values()):
            raise AssertionError("both checks must finish before either creation")
        finished = {}
        if order is None:
            for name in ("A", "B"):
                parents[name].send("create")
            for name in ("A", "B"):
                finished[name] = receive(parents[name], deadline)
        else:
            for name in order:
                parents[name].send("create")
                finished[name] = receive(parents[name], deadline)
        for process in processes.values():
            process.join(max(0, deadline - time.monotonic()))
            if process.is_alive() or process.exitcode != 0:
                raise RuntimeError("child did not exit normally before deadline")
        return {"both_checked_absent": True,
                "outcomes": {name: finished[name]["result"] for name in ("A", "B")},
                "content": path.read_text(encoding="ascii"),
                "children_exited_zero": True}
    finally:
        for connection in parents.values():
            connection.close()
        for process in processes.values():
            if process.pid is not None and process.is_alive():
                process.terminate()
                process.join(2)
            if process.pid is not None and process.is_alive():
                process.kill()
                process.join(2)
            if process.pid is not None and not process.is_alive():
                process.close()


def main():
    checks = 0

    def check(condition):
        nonlocal checks
        if not condition:
            raise AssertionError("file creation check failed")
        checks += 1

    controlled = {}
    with tempfile.TemporaryDirectory(prefix="exclusive-create-") as folder:
        for mode in ("w", "x"):
            for order in (("A", "B"), ("B", "A")):
                label = mode + "_" + "".join(order)
                result = run_round(folder, label, mode, order)
                check(result["both_checked_absent"])
                check(result["children_exited_zero"])
                successes = sum(v == "created_or_written" for v in result["outcomes"].values())
                check(successes == (2 if mode == "w" else 1))
                check(result["content"] == (order[-1] if mode == "w" else order[0]))
                check(result["outcomes"][order[0]] == "created_or_written")
                check(result["outcomes"][order[1]] ==
                      ("created_or_written" if mode == "w" else "already_exists"))
                controlled[label] = result

        raced = run_round(folder, "x_unordered", "x", None)
        winners = [name for name, status in raced["outcomes"].items()
                   if status == "created_or_written"]
        check(raced["both_checked_absent"])
        check(raced["children_exited_zero"])
        check(len(winners) == 1)
        check(list(raced["outcomes"].values()).count("already_exists") == 1)
        check(raced["content"] == winners[0])

        existing = Path(folder) / "existing.txt"
        existing.write_text("keep-me", encoding="ascii")
        try:
            with existing.open("x", encoding="ascii"):
                pass
        except FileExistsError:
            check(True)
        else:
            raise AssertionError("exclusive creation replaced an existing file")
        check(existing.read_text(encoding="ascii") == "keep-me")

    print(json.dumps({"checks_passed": checks, "real_child_processes": 10,
                      "child_console": "hidden via pythonw" if os.name == "nt" else "not applicable",
                      "controlled_rounds": controlled,
                      "unordered_exclusive_round": {
                          "both_checked_absent": True, "successes": 1,
                          "already_exists": 1, "content_matches_winner": True,
                          "winner_order_is_not_guaranteed": True},
                      "preexisting_content_preserved": True,
                      "scope": "local temporary files; creation does not atomically publish payload or grant a permanent lock"},
                     ensure_ascii=False, indent=2))


if __name__ == "__main__":
    mp.freeze_support()
    if os.name == "nt":
        # This experiment has no interactive child UI. Keep Windows workers hidden.
        pythonw = Path(sys.executable).with_name("pythonw.exe")
        if not pythonw.is_file():
            raise RuntimeError("Windows workers require pythonw.exe beside this Python interpreter")
        mp.set_executable(str(pythonw))
    main()