Python C 程序子进程卡在 "for line in iter"

Question

好的，我正在尝试从 python 脚本运行 C 程序。目前我正在使用测试 C 程序:

#include <stdio.h>

int main() {
    while (1) {
        printf("2000\n");
        sleep(1);
    }
    return 0;
}

模拟我将使用的程序，它不断地从传感器获取读数。然后我尝试从 C 程序中读取输出(在本例中为 "2000")，在 python 中使用子进程:

#!usr/bin/python
import subprocess

process = subprocess.Popen("./main", stdout=subprocess.PIPE)
while True:
    for line in iter(process.stdout.readline, ''):
            print line,

但这行不通。从使用 print 语句开始，它运行 .Popen 行，然后在 for line in iter(process.stdout.readline, ''): 处等待，直到我按下 Ctrl-C .

这是为什么？这正是我见过的大多数示例的代码，但它不读取文件。

有没有办法让它只在有内容可读时运行？

Answer 1

这是一个 block 缓冲问题。

以下是我对 Python: read streaming input from subprocess.communicate() 的回答的扩展版问题。

直接在 C 程序中修复标准输出缓冲区

如果基于

stdio 的程序在终端中以交互方式运行，则它们通常是行缓冲的，而当它们的 stdout 被重定向到管道时，它们是 block 缓冲的。在后一种情况下，在缓冲区溢出或刷新之前您不会看到新行。

为避免在每次 printf() 调用后调用 fflush()，您可以通过在最开始调用 C 程序来强制行缓冲输出:

setvbuf(stdout, (char *) NULL, _IOLBF, 0); /* make line buffered stdout */

在这种情况下，一旦打印出换行符，缓冲区就会被刷新。

或者不修改C程序源码修复

stdbuf 实用程序允许您在不修改源代码的情况下更改缓冲类型，例如:

from subprocess import Popen, PIPE

process = Popen(["stdbuf", "-oL", "./main"], stdout=PIPE, bufsize=1)
for line in iter(process.stdout.readline, b''):
    print line,
process.communicate() # close process' stream, wait for it to exit

还有其他实用程序可用，请参阅 Turn off buffering in pipe .

或者使用伪TTY

要诱使子进程认为它正在交互式运行，您可以使用 pexpect module或其类似物，有关使用 pexpect 和 pty 模块的代码示例，请参阅 Python subprocess readlines() hangs .下面是那里提供的 pty 示例的一个变体(它应该在 Linux 上工作):

#!/usr/bin/env python
import os
import pty
import sys
from select import select
from subprocess import Popen, STDOUT

master_fd, slave_fd = pty.openpty()  # provide tty to enable line buffering
process = Popen("./main", stdin=slave_fd, stdout=slave_fd, stderr=STDOUT,
                bufsize=0, close_fds=True)
timeout = .1 # ugly but otherwise `select` blocks on process' exit
# code is similar to _copy() from pty.py
with os.fdopen(master_fd, 'r+b', 0) as master:
    input_fds = [master, sys.stdin]
    while True:
        fds = select(input_fds, [], [], timeout)[0]
        if master in fds: # subprocess' output is ready
            data = os.read(master_fd, 512) # <-- doesn't block, may return less
            if not data: # EOF
                input_fds.remove(master)
            else:
                os.write(sys.stdout.fileno(), data) # copy to our stdout
        if sys.stdin in fds: # got user input
            data = os.read(sys.stdin.fileno(), 512)
            if not data:
                input_fds.remove(sys.stdin)
            else:
                master.write(data) # copy it to subprocess' stdin
        if not fds: # timeout in select()
            if process.poll() is not None: # subprocess ended
                # and no output is buffered <-- timeout + dead subprocess
                assert not select([master], [], [], 0)[0] # race is possible
                os.close(slave_fd) # subproces don't need it anymore
                break
rc = process.wait()
print("subprocess exited with status %d" % rc)

或者通过pexpect使用pty

pexpect 将 pty 处理包装到 higher level interface 中:

#!/usr/bin/env python
import pexpect

child = pexpect.spawn("/.main")
for line in child:
    print line,
child.close()

Q: Why not just use a pipe (popen())?解释伪 TTY 为何有用。