【发布时间】：2018-10-19 13:19:59
【问题描述】：
如何确定对 sys.stdin.readline() 的调用（或更一般地，对任何基于文件描述符的文件对象的 readline() 调用）是否会阻塞？
当我在 python 中编写基于行的文本过滤程序时会出现这种情况； 也就是说，程序反复从输入中读取一行文本，可能会对其进行转换，然后将其写入输出。
我想实施一个合理的输出缓冲策略。 我的标准是：
- 在处理数以百万计的数据时应该是高效的 批量行 - 主要缓冲输出，偶尔刷新。
- 它不应该在保持缓冲输出的同时阻塞输入。
因此，无缓冲输出不好，因为它违反了 (1)（对操作系统的写入过多）。 并且行缓冲输出不好，因为它仍然违反（1） （在一百万行中的每一行上将输出刷新到操作系统是没有意义的）。 并且默认缓冲输出不好，因为它违反了（2）（如果输出到文件或管道，它将不适当地保留输出）。
我认为，在大多数情况下，一个好的解决方案是： “每当（其缓冲区已满或）sys.stdin.readline() 即将阻塞时刷新 sys.stdout”。 可以实现吗？
（请注意，我并不认为此策略适用于所有案例。例如， 在程序受 CPU 限制的情况下，这可能并不理想；在这种情况下，这可能是明智的 更频繁地刷新，以避免在进行长时间计算时保留输出。）
为了明确起见，假设我正在 python 中实现 unix 的“cat -n”程序。
(实际上 "cat -n" 比 line-at-a-time 更智能；也就是说，它知道如何 在读取整行之前读取和写入行的一部分； 但是，对于这个例子，无论如何我都会一次一行地实现它。）
行缓冲实现
（表现良好，但违反标准（1），即由于冲洗过多，速度过慢）：
#!/usr/bin/python
# cat-n.linebuffered.py
import sys
num_lines_read = 0
while True:
line = sys.stdin.readline()
if line == '': break
num_lines_read += 1
print("%d: %s" % (num_lines_read, line))
sys.stdout.flush()
默认缓冲实现
（快速但违反标准（2），即不友好的输出扣留）
#!/usr/bin/python
# cat-n.defaultbuffered.py
import sys
num_lines_read = 0
while True:
line = sys.stdin.readline()
if line == '': break
num_lines_read += 1
print("%d: %s" % (num_lines_read, line))
期望的实现：
#!/usr/bin/python
num_lines_read = 0
while True:
if sys_stdin_readline_is_about_to_block(): # <--- How do I implement this??
sys.stdout.flush()
line = sys.stdin.readline()
if line == '': break
num_lines_read += 1
print("%d: %s" % (num_lines_read, line))
那么问题来了：是否可以实现sys_stdin_readline_is_about_to_block()？
我想要一个适用于 python2 和 python3 的答案。 我已经研究了以下每种技术，但到目前为止都没有成功。
使用
select([sys.stdin],[],[],0)确定从 sys.stdin 读取是否会阻塞。 （当 sys.stdin 是缓冲文件对象时，这不起作用，至少有一个可能有两个原因：（1）如果部分行准备好从底层输入管道读取，它会错误地说“不会阻塞”， (2) 如果 sys.stdin 的缓冲区包含完整的输入行但底层管道还没有准备好进行额外读取，它会错误地说“将阻塞”......我认为）。非阻塞 io，使用
os.fdopen(sys.stdin.fileno(), 'r')和fcntl和O_NONBLOCK（在任何 python 版本中，我都无法让它与 readline() 一起使用： 在 python2.7 中，只要有部分行进入，它就会丢失输入； 在python3中，似乎无法区分“会阻塞” 和输入结束。 ??)asyncio（我不清楚 python2 中有什么可用的；我认为它不适用于 sys.stdin；但是，我仍然对仅有效的答案感兴趣从 subprocess.Popen()) 返回的管道读取时。
创建一个线程来执行
readline()循环并将每一行传递给主线程 通过 queue.Queue 编程；然后主程序可以在之前轮询队列 从中读取每一行，每当它看到它即将阻塞时，首先刷新标准输出。 （我试过了，实际上它可以工作了，见下文，但它非常慢，比行缓冲慢得多。）
线程实现：
请注意，这并没有严格回答“如何判断 sys.stdin.readline() 是否会阻塞”的问题，但无论如何它设法实现了所需的缓冲策略。不过速度太慢了。
#!/usr/bin/python
# cat-n.threaded.py
import queue
import sys
import threading
def iter_with_abouttoblock_cb(callable, sentinel, abouttoblock_cb, qsize=100):
# child will send each item through q to parent.
q = queue.Queue(qsize)
def child_fun():
for item in iter(callable, sentinel):
q.put(item)
q.put(sentinel)
child = threading.Thread(target=child_fun)
# The child thread normally runs until it sees the sentinel,
# but we mark it daemon so that it won't prevent the parent
# from exiting prematurely if it wants.
child.daemon = True
child.start()
while True:
try:
item = q.get(block=False)
except queue.Empty:
# q is empty; call abouttoblock_cb before blocking
abouttoblock_cb()
item = q.get(block=True)
if item == sentinel:
break # do *not* yield sentinel
yield item
child.join()
num_lines_read = 0
for line in iter_with_abouttoblock_cb(sys.stdin.readline,
sentinel='',
abouttoblock_cb=sys.stdout.flush):
num_lines_read += 1
sys.stdout.write("%d: %s" % (num_lines_read, line))
验证缓冲行为：
以下命令（在 linux 上的 bash 中）显示了预期的缓冲行为：“defaultbuffered”缓冲过于激进，而“linebuffered”和“threaded”缓冲恰到好处。
（注意流水线末尾的| cat是默认做python block-buffer而不是line-buffer的。）
for which in defaultbuffered linebuffered threaded; do
for python in python2.7 python3.5; do
echo "$python cat-n.$which.py:"
(echo z; echo -n a; sleep 1; echo b; sleep 1; echo -n c; sleep 1; echo d; echo x; echo y; echo z; sleep 1; echo -n e; sleep 1; echo f) | $python cat-n.$which.py | cat
done
done
输出：
python2.7 cat-n.defaultbuffered.py:
[... pauses 5 seconds here. Bad! ...]
1: z
2: ab
3: cd
4: x
5: y
6: z
7: ef
python3.5 cat-n.defaultbuffered.py:
[same]
python2.7 cat-n.linebuffered.py:
1: z
[... pauses 1 second here, as expected ...]
2: ab
[... pauses 2 seconds here, as expected ...]
3: cd
4: x
5: y
6: z
[... pauses 2 seconds here, as expected ...]
6: ef
python3.5 cat-n.linebuffered.py:
[same]
python2.7 cat-n.threaded.py:
[same]
python3.5 cat-n.threaded.py:
[same]
时间安排：
（在 linux 上的 bash 中）：
for which in defaultbuffered linebuffered threaded; do
for python in python2.7 python3.5; do
echo -n "$python cat-n.$which.py: "
timings=$(time (yes 01234567890123456789012345678901234567890123456789012345678901234567890123456789 | head -1000000 | $python cat-n.$which.py >| /tmp/REMOVE_ME) 2>&1)
echo $timings
done
done
/bin/rm /tmp/REMOVE_ME
输出：
python2.7 cat-n.defaultbuffered.py: real 0m1.490s user 0m1.191s sys 0m0.386s
python3.5 cat-n.defaultbuffered.py: real 0m1.633s user 0m1.007s sys 0m0.311s
python2.7 cat-n.linebuffered.py: real 0m5.248s user 0m2.198s sys 0m2.704s
python3.5 cat-n.linebuffered.py: real 0m6.462s user 0m3.038s sys 0m3.224s
python2.7 cat-n.threaded.py: real 0m25.097s user 0m18.392s sys 0m16.483s
python3.5 cat-n.threaded.py: real 0m12.655s user 0m11.722s sys 0m1.540s
重申一下，我想要一个在保持缓冲输出时从不阻塞的解决方案 （“线缓冲”和“线程”在这方面都很好）， 这也很快：也就是说，速度与“defaultbuffered”相当。
【问题讨论】：
-
我不确定您是否可以知道不会出错
stdin.readline()是否会阻止。因此，我不知道您想要的实现是否可行。
标签： python