Question

我在Windows（Win7）上有一个程序，每x秒写一个txt文件。现在我有一个python脚本，每x秒读取一次这个txt文件。当python脚本读取文件并同时另一个程序想要写入该文件时 - 写入程序崩溃（并显示权限错误）。由于我无法修改程序写入txt文件的方式，因此我必须尝试打开txt文件而不阻止编写程序。有人知道在这种情况下我能做些什么（无阻塞地阅读）关于这个话题的每一个提示，我都会非常高兴！

尝试读取文件的程序代码如下：

    with codecs.open(datapath, "r", 'utf-16') as raw_data:

         raw_data_x = raw_data.readlines()

我必须用“编解码器”打开文件，因为它在unicode中。

Answer 1

经过很长一段时间，我设法创建了一个在ctypes中为你做的功能。请记住，这只有在流程没有获得＆＃34; Exclusive＆＃34;访问。如果确实如此，那么您运气不好，需要使用如here所示的影子副本服务或实施here。无论如何，你走了：

import ctypes
from ctypes import wintypes
import os
import msvcrt

GENERIC_READ = 0x80000000
GENERIC_WRITE = 0x40000000

OPEN_EXISTING = 3
OPEN_ALWAYS = 4

ACCESS_MODES = {
    "r": GENERIC_READ,
    "w": GENERIC_WRITE,
    "r+": (GENERIC_READ|GENERIC_WRITE)
}

OPEN_MODES = {
    "r": OPEN_EXISTING,
    "w": OPEN_ALWAYS,
    "r+": OPEN_ALWAYS,
}


def open_file_nonblocking(filename, access):
    # Removes the b for binary access.
    internal_access = access.replace("b", "")
    access_mode = ACCESS_MODES[internal_access]
    open_mode = OPEN_MODES[internal_access]
    handle = wintypes.HANDLE(ctypes.windll.kernel32.CreateFileW(
        wintypes.LPWSTR(filename),
        wintypes.DWORD(access_mode),
        wintypes.DWORD(2|1),  # File share read and write
        ctypes.c_void_p(0),
        wintypes.DWORD(open_mode),
        wintypes.DWORD(0),
        wintypes.HANDLE(0)
    ))

    try:
        fd = msvcrt.open_osfhandle(handle.value, 0)
    except OverflowError as exc:
        # Python 3.X
        raise OSError("Failed to open file.") from None
        # Python 2
        # raise OSError("Failed to open file.")

    return os.fdopen(fd, access)

该函数在共享读写句柄时打开文件，允许多次访问。然后它将句柄转换为普通的python文件对象确保在完成后关闭文件。

Answer 2

最近我不得不在stdin上进行I / O读取，在python中使用跨平台兼容性的stdout 对于linux ：
对于linux，我们可以使用select模块。它是posix select函数的包装实现。它允许您传递多个文件描述符，等待它们准备好。一旦准备好，您将收到通知，并且可以执行read/write操作。这里有一些代码可以让你有个想法这里nodejs是一个具有nodejs image的docker环境

  stdin_buf = BytesIO(json.dumps(fn) + "\n")
  stdout_buf = BytesIO()
  stderr_buf = BytesIO()

  rselect = [nodejs.stdout, nodejs.stderr]  # type: List[BytesIO]
  wselect = [nodejs.stdin]  # type: List[BytesIO]
  while (len(wselect) + len(rselect)) > 0:
            rready, wready, _ = select.select(rselect, wselect, [])
            try:
                if nodejs.stdin in wready:
                    b = stdin_buf.read(select.PIPE_BUF)
                    if b:
                        os.write(nodejs.stdin.fileno(), b)
                    else:
                        wselect = []
                for pipes in ((nodejs.stdout, stdout_buf), (nodejs.stderr, stderr_buf)):
                    if pipes[0] in rready:
                        b = os.read(pipes[0].fileno(), select.PIPE_BUF)
                        if b:
                            pipes[1].write(b)
                        else:
                            rselect.remove(pipes[0])
                if stdout_buf.getvalue().endswith("\n"):
                    rselect = []
            except OSError as e:
                break

适用于Windows 此代码示例包含stdin的读写操作，涉及stdout。现在这段代码不适用于Windows操作系统，因为在Windows上选择实现不允许stdin，stdout作为参数传递。
Docs说：

Windows上的文件对象是不可接受的，但是套接字是。在Windows上，底层的select（）函数由WinSock库提供，不处理不是源自WinSock的文件描述符。

首先我要提一下，在asyncio（python 3），gevent（对于python 2.7），msvcrt这样的窗口上有很多用于非阻塞I / O读取的库。然后有pywin32个win32event，如果您的套接字已准备好read/write数据，则会提醒您。但是他们都没有允许我在stdin/stdout上写下像是给像errros一样的写作 An operation is performend on something that is not a socket
Handles only expect integer values等我还没有尝试过其他一些像twister这样的库。

现在，为了在Windows平台上实现上述代码中的功能，我使用了threads。这是我的代码：

    stdin_buf = BytesIO(json.dumps(fn) + "\n")
    stdout_buf = BytesIO()
    stderr_buf = BytesIO()

    rselect = [nodejs.stdout, nodejs.stderr]  # type: List[BytesIO]
    wselect = [nodejs.stdin]  # type: List[BytesIO]
    READ_BYTES_SIZE = 512

    # creating queue for reading from a thread to queue
    input_queue = Queue.Queue()
    output_queue = Queue.Queue()
    error_queue = Queue.Queue()

    # To tell threads that output has ended and threads can safely exit
    no_more_output = threading.Lock()
    no_more_output.acquire()
    no_more_error = threading.Lock()
    no_more_error.acquire()

    # put constructed command to input queue which then will be passed to nodejs's stdin
    def put_input(input_queue):
        while True:
            sys.stdout.flush()
            b = stdin_buf.read(READ_BYTES_SIZE)
            if b:
                input_queue.put(b)
            else:
                break

    # get the output from nodejs's stdout and continue till otuput ends
    def get_output(output_queue):
        while not no_more_output.acquire(False):
            b=os.read(nodejs.stdout.fileno(), READ_BYTES_SIZE)
            if b:
                output_queue.put(b)

    # get the output from nodejs's stderr and continue till error output ends
    def get_error(error_queue):
        while not no_more_error.acquire(False):
            b = os.read(nodejs.stderr.fileno(), READ_BYTES_SIZE)
            if b:
                error_queue.put(b)

    # Threads managing nodejs.stdin, nodejs.stdout and nodejs.stderr respectively
    input_thread = threading.Thread(target=put_input, args=(input_queue,))
    input_thread.start()
    output_thread = threading.Thread(target=get_output, args=(output_queue,))
    output_thread.start()
    error_thread = threading.Thread(target=get_error, args=(error_queue,))
    error_thread.start()

    # mark if output/error is ready
    output_ready=False
    error_ready=False

    while (len(wselect) + len(rselect)) > 0:
        try:
            if nodejs.stdin in wselect:
                if not input_queue.empty():
                    os.write(nodejs.stdin.fileno(), input_queue.get())
                elif not input_thread.is_alive():
                    wselect = []
            if nodejs.stdout in rselect:
                if not output_queue.empty():
                    output_ready = True
                    stdout_buf.write(output_queue.get())
                elif output_ready:
                    rselect = []
                    no_more_output.release()
                    no_more_error.release()
                    output_thread.join()

            if nodejs.stderr in rselect:
                if not error_queue.empty():
                    error_ready = True
                    stderr_buf.write(error_queue.get())
                elif error_ready:
                    rselect = []
                    no_more_output.release()
                    no_more_error.release()
                    output_thread.join()
                    error_thread.join()
            if stdout_buf.getvalue().endswith("\n"):
                rselect = []
                no_more_output.release()
                no_more_error.release()
                output_thread.join()
        except OSError as e:
            break

所以对我来说最好的选择就是线程。如果您想了解更多内容，本文将为nice read。

python读取文件在Windows上无阻塞

2 个答案: