python - O_NONBLOCK 不会在 Python 中引发异常

Question

我正在尝试编写一个“更干净”的程序来释放在命名管道处被阻塞的潜在编写器(因为没有读取器正在从管道读取)。但是，当没有写入器被阻塞写入管道时，清理器本身不应阻塞。换句话说，“清理器”必须立即返回/终止，无论是否有被阻止的写入器。

因此我搜索了“Python non-blocking read from named pipe”，得到了这些:

1. How to read named FIFO non-blockingly?
2. fifo - reading in a loop
3. What conditions result in an opened, nonblocking named pipe (fifo) being "unavailable" for reads?
4. Why does a read-only open of a named pipe block?

他们似乎建议简单地使用 os.open(file_name, os.O_RDONLY | os.O_NONBLOCK) 应该没问题，但这在我的机器上并没有真正起作用。我想我可能在某个地方搞砸了或者误解了他们的一些建议/情况。但是，我自己真的想不通是怎么回事。

我找到了 Linux 手册页(http://man7.org/linux/man-pages/man2/open.2.html)，O_NONBLOCK 的解释似乎与他们的建议一致，但与我在我的机器上观察到的不一致......

以防万一，我的操作系统是Ubuntu 14.04 LTS 64-bit。

这是我的代码:

import os
import errno

BUFFER_SIZE = 65536

ph = None
try:
    ph = os.open("pipe.fifo", os.O_RDONLY | os.O_NONBLOCK)
    os.read(ph, BUFFER_SIZE)
except OSError as err:
    if err.errno == errno.EAGAIN or err.errno == errno.EWOULDBLOCK:
        raise err
    else:
        raise err
finally:
    if ph:
        os.close(ph)

(不知道Python语法高亮怎么做...)

本来只有第二个raise，后来发现os.open和os.read，虽然不是blocking，don'也不会引发任何异常...我真的不知道作者将向缓冲区写入多少内容!如果非阻塞 read 没有引发异常，我怎么知道什么时候停止阅读？

---

2016 年 8 月 8 日更新:

这似乎是满足我需要的解决方法/解决方案:

import os
import errno

BUFFER_SIZE = 65536

ph = None
try:
    ph = os.open("pipe.fifo", os.O_RDONLY | os.O_NONBLOCK)
    while True:
        buffer = os.read(ph, BUFFER_SIZE)
        if len(buffer) < BUFFER_SIZE:
            break
except OSError as err:
    if err.errno == errno.EAGAIN or err.errno == errno.EWOULDBLOCK:
        pass # It is supposed to raise one of these exceptions
    else:
        raise err
finally:
    if ph:
        os.close(ph)

它将在read 时循环。每次读取内容时，它都会将读取内容的大小与指定的 BUFFER_SIZE 进行比较，直到达到 EOF(然后 writer 将解除阻塞并继续/退出)。

我还是想知道为什么那个read没有异常。

---

2016 年 8 月 10 日更新:

说清楚一点，我的总体目标是这样的。

我的主程序 (Python) 有一个线程作为读取器。它通常阻塞在命名管道上，等待“命令”。有一个编写器程序(Shell 脚本)，它会在每次运行时将单行“命令”写入同一管道。

在某些情况下，编写器会在我的主程序启动之前或在我的主程序终止之后启动。在这种情况下，作者将阻塞在等待读者的管道上。这样，如果稍后我的主程序启动，它将立即从管道读取以从被阻止的编写器中获取该“命令”——这不是我想要的。我希望我的程序忽略在它之前开始的编写器。

因此，我的解决方案是，在读取器线程初始化期间，我进行非阻塞读取以释放写入器，而不真正执行他们试图写入管道的“命令”。

Answer 1

这个解决方案是不正确的。

while True:
    buffer = os.read(ph, BUFFER_SIZE)
    if len(buffer) < BUFFER_SIZE:
        break

这实际上不会读取所有内容，它只会读取到部分读取为止。请记住:您只能保证用常规文件填充缓冲区，在所有其他情况下，有可能在 EOF 之前获得部分缓冲区。正确的做法是循环直到到达文件的实际末尾，这将给出长度为 0 的读取。文件末尾表示没有写入器(它们都已退出或关闭 fifo)。

while True:
    buffer = os.read(ph, BUFFER_SIZE)
    if not buffer:
        break

但是，这在面对非阻塞 IO 时将无法正常工作。事实证明，这里完全不需要非阻塞 IO。

import os
import fcntl

h = os.open("pipe.fifo", os.O_RDONLY | os.O_NONBLOCK)
# Now that we have successfully opened it without blocking,
# we no longer want the handle to be non-blocking
flags = fcntl.fcntl(h, fcntl.F_GETFL)
flags &= ~os.O_NONBLOCK
fcntl.fcntl(h, fcntl.F_SETFL, flags)
try:
    while True:
        # Only blocks if there is a writer
        buf = os.read(h, 65536)
        if not buf:
            # This happens when there are no writers
            break
finally:
    os.close(h)

唯一会导致此代码阻塞的情况是，如果有一个事件的写入器打开了 fifo 但没有写入它。从您的描述来看，情况似乎并非如此。

非阻塞 IO 不会那样做

你的程序想根据情况做两件事:

1. 如果没有作家，立即返回。

2. 如果有writer，则从FIFO中读取数据，直到writer完成。

非阻塞 read() 对任务 #1 没有任何影响。无论您是否使用 O_NONBLOCK，read() 都会在情况 #1 中立即返回。所以唯一的区别是情况 #2。

在情况 #2 中，您的程序的目标是从写入器读取整个数据 block 。这正是阻塞 IO 的工作原理:它等待编写器完成，然后 read() 返回。非阻塞 IO 的全部意义在于，如果操作不能立即完成，则提前返回，这与程序的目标相反——等待操作完成。

如果您使用非阻塞 read()，在情况 #2 中，您的程序有时会在写入程序完成工作之前提前返回。或者您的程序可能会在从 FIFO 中读取一半命令后返回，而将另一半(现在已损坏)留在那里。您的问题中表达了这种担忧:

If the non blocking read does not raise exception, how should I know when to stop reading?

您知道何时停止读取，因为当所有编写器关闭管道时 read() 返回零字节。 (方便的是，如果一开始就没有写入器，也会发生这种情况。)不幸的是，如果写入器在完成后没有关闭管道末端，则不会发生这种情况。如果 writers 在完成后关闭管道，则更简单、更直接，因此这是推荐的解决方案，即使您需要稍微修改 writers。如果作者出于某种原因无法关闭管道，则解决方案会更加复杂。

非阻塞 read() 的主要用例是当 IO 在后台进行时您的程序有一些其他任务要完成。