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 位。

这是我的代码：

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虽然没有阻塞，但也没有引发任何异常……我真的不知道作者会写入缓冲区！如果非阻塞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（然后写入器将解除阻塞并继续/退出）。

我仍然想知道为什么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. 如果有写入器，则从 FIFO 中读取数据，直到写入器完成。

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

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

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

如果非阻塞读取没有引发异常，我应该如何知道何时停止读取？

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

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

Answer 2

在 POSIX C 程序中，如果 read() 尝试从空管道或 FIFO 特殊文件中读取，它会产生以下结果之一：

• 如果没有进程打开管道进行写入，read() 返回 0 表示文件结束。
• 如果某个进程打开了写入管道并且 O_NONBLOCK 设置为 1，则 read() 返回 -1 并将 errno 设置为 EAGAIN。
• 如果某个进程打开了用于写入的管道并且 O_NONBLOCK 设置为 0，则 read() 会阻塞（即不返回）直到某些数据被写入，或者管道被所有其他拥有该管道的进程关闭开放写作。

所以，首先检查是否有写入器仍然打开fifo进行写入。如果没有人，读取将得到一个空字符串，没有异常。否则会抛出异常