Python `io.open` intermittently throw `PermissionError` on windows

Bug report

Bug description:

The io.open method intermittently raises a PermissionError on the Windows operating system. I've attached a Python script that reproduces this issue on version 3.12.8, and 3.11.9 (didn't test for any other version)

My investigation suggests that the problem arises from consecutive write operations performed within very short timeframes where each operation does fresh io.open to write updates -- For example, when attempting to write 10 updates back-to-back to a file with fresh io.open each time.

On Windows, explorer.exe runs in the background to update indexing and metadata upon file modification. If explorer.exe has already acquired a handle to the file, any new request to write to it will result in a PermissionError.

While we could implement a retry mechanism with backoff for io.open in our code, I'm curious why Python doesn't natively handle such background process contention.

import time
import threading
import random
import multiprocessing
import os

# Sample message text
MESSAGE = (
    r"file://C:\Users\sample\Desktop\temp\tmpgzy8f_lt\929cec70297d4938b31545f858d6b38c.txt,"
    r"gs://sample-bucket/loadwintest/hdahsdhahdahsdhahd/temp/dahsdhahdhadhahdh/dhahsdahdhahdhahdahdhahdha.txt,"
    r"2025-07-21T10:44:43.263442Z,2025-07-21T11:00:55.588213Z,dahshdahdhahdhahshah+hfQ==,25000000000,25000000000,OK,"
)

# Output file path
output_file = "winman/test_output11.txt"


# Writer process – gets messages from queue and writes to file
def writer(queue, end_time):
    while time.time() < end_time:
        msg = queue.get()
        with open(output_file, "at", encoding='utf-8', newline='\n') as f:
            f.write(msg + '\n')


# Thread that puts messages into the queue
def thread_worker(queue, thread_id, process_id, end_time):
    while time.time() < end_time:
        notify_msg = f"[P{process_id}-T{thread_id}] {MESSAGE}"
        queue.put(notify_msg)
        time.sleep(random.choice([0.3, 0.5, 0.4]))


# Process that spawns multiple threads
def process_worker(queue, num_threads, process_id, end_time):
    threads = []
    for tid in range(num_threads):
        t = threading.Thread(target=thread_worker, args=(queue, tid, process_id, end_time))
        threads.append(t)
        t.start()

    for t in threads:
        t.join()


def main():
    runtime_seconds = 600
    end_time = time.time() + runtime_seconds

    num_processes = 4
    threads_per_process = 4

    queue = multiprocessing.Queue()

    # Start writer process
    writer_proc = multiprocessing.Process(target=writer, args=(queue, end_time))
    writer_proc.start()

    # Start worker processes
    processes = []
    for pid in range(num_processes):
        p = multiprocessing.Process(target=process_worker, args=(queue, threads_per_process, pid, end_time))
        p.start()
        processes.append(p)

    # Wait for all worker processes
    for p in processes:
        p.join()

    # Terminate writer after work is done
    writer_proc.terminate()
    writer_proc.join()


if __name__ == "__main__":
    main()

CPython versions tested on:

3.12

Operating systems tested on:

Windows

首先，在 Windows 上使用报告的 CPython 版本运行随附的 Python 复现程序，并确认是否能够复现间歇性的 PermissionError。然后检查 io.open 入口点以及 Windows 上相关的文件打开行为；这项工作应确定一个可复现的原因，以及一个范围明确的修复方案或一项已记录的限制。