停止阅读过程输出，而无需挂起？
https://stackoverflow.com/questions/4417962
-
08-10-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
Russian题
我有一个针对Linux的Python程序，几乎看起来像这样：
import os
import time
process = os.popen("top").readlines()
time.sleep(1)
os.popen("killall top")
print process
该程序悬挂在此行中：
process = os.popen("top").readlines()
这发生在保持更新输出之类的工具中
我最好的试验：
import os
import time
import subprocess
process = subprocess.Popen('top')
time.sleep(2)
os.popen("killall top")
print process
它比第一个（凯是）更好，但返回：
<subprocess.Popen object at 0x97a50cc>
第二次试验：
import os
import time
import subprocess
process = subprocess.Popen('top').readlines()
time.sleep(2)
os.popen("killall top")
print process
与第一个相同。它由于“ readlines（）”而被绞死
它的返回应该是这样：
top - 05:31:15 up 12:12, 5 users, load average: 0.25, 0.14, 0.11
Tasks: 174 total, 2 running, 172 sleeping, 0 stopped, 0 zombie
Cpu(s): 9.3%us, 3.8%sy, 0.1%ni, 85.9%id, 0.9%wa, 0.0%hi, 0.0%si, 0.0%st
Mem: 1992828k total, 1849456k used, 143372k free, 233048k buffers
Swap: 4602876k total, 0k used, 4602876k free, 1122780k cached
PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND
31735 Barakat 20 0 246m 52m 20m S 19.4 2.7 13:54.91 totem
1907 root 20 0 91264 45m 15m S 1.9 2.3 38:54.14 Xorg
2138 Barakat 20 0 17356 5368 4284 S 1.9 0.3 3:00.15 at-spi-registry
2164 Barakat 9 -11 164m 7372 6252 S 1.9 0.4 2:54.58 pulseaudio
2394 Barakat 20 0 27212 9792 8256 S 1.9 0.5 6:01.48 multiload-apple
6498 Barakat 20 0 56364 30m 18m S 1.9 1.6 0:03.38 pyshell
1 root 20 0 2880 1416 1208 S 0.0 0.1 0:02.02 init
2 root 20 0 0 0 0 S 0.0 0.0 0:00.02 kthreadd
3 root RT 0 0 0 0 S 0.0 0.0 0:00.12 migration/0
4 root 20 0 0 0 0 S 0.0 0.0 0:02.07 ksoftirqd/0
5 root RT 0 0 0 0 S 0.0 0.0 0:00.00 watchdog/0
9 root 20 0 0 0 0 S 0.0 0.0 0:01.43 events/0
11 root 20 0 0 0 0 S 0.0 0.0 0:00.00 cpuset
12 root 20 0 0 0 0 S 0.0 0.0 0:00.02 khelper
13 root 20 0 0 0 0 S 0.0 0.0 0:00.00 netns
14 root 20 0 0 0 0 S 0.0 0.0 0:00.00 async/mgr
15 root 20 0 0 0 0 S 0.0 0.0 0:00.00 pm
并保存在变量“过程”中。我知道伙计们，我现在真的卡住了吗？
解决方案
#!/usr/bin/env python
"""Start process; wait 2 seconds; kill the process; print all process output."""
import subprocess
import tempfile
import time
def main():
# open temporary file (it automatically deleted when it is closed)
# `Popen` requires `f.fileno()` so `SpooledTemporaryFile` adds nothing here
f = tempfile.TemporaryFile()
# start process, redirect stdout
p = subprocess.Popen(["top"], stdout=f)
# wait 2 seconds
time.sleep(2)
# kill process
#NOTE: if it doesn't kill the process then `p.wait()` blocks forever
p.terminate()
p.wait() # wait for the process to terminate otherwise the output is garbled
# print saved output
f.seek(0) # rewind to the beginning of the file
print f.read(),
f.close()
if __name__=="__main__":
main()
仅打印输出部分的尾巴状解决方案
您可以在另一个线程中读取进程输出，并在队列中保存所需的最后一行：
import collections
import subprocess
import time
import threading
def read_output(process, append):
for line in iter(process.stdout.readline, ""):
append(line)
def main():
# start process, redirect stdout
process = subprocess.Popen(["top"], stdout=subprocess.PIPE, close_fds=True)
try:
# save last `number_of_lines` lines of the process output
number_of_lines = 200
q = collections.deque(maxlen=number_of_lines) # atomic .append()
t = threading.Thread(target=read_output, args=(process, q.append))
t.daemon = True
t.start()
#
time.sleep(2)
finally:
process.terminate() #NOTE: it doesn't ensure the process termination
# print saved lines
print ''.join(q)
if __name__=="__main__":
main()
这种变体需要 q.append() 是原子操作。否则，输出可能会损坏。
signal.alarm() 解决方案
您可以使用 signal.alarm() 打电话 process.terminate() 在指定超时之后，而不是在另一个线程中读取。虽然它可能与 subprocess 模块。基于 @Alex Martelli的答案:
import collections
import signal
import subprocess
class Alarm(Exception):
pass
def alarm_handler(signum, frame):
raise Alarm
def main():
# start process, redirect stdout
process = subprocess.Popen(["top"], stdout=subprocess.PIPE, close_fds=True)
# set signal handler
signal.signal(signal.SIGALRM, alarm_handler)
signal.alarm(2) # produce SIGALRM in 2 seconds
try:
# save last `number_of_lines` lines of the process output
number_of_lines = 200
q = collections.deque(maxlen=number_of_lines)
for line in iter(process.stdout.readline, ""):
q.append(line)
signal.alarm(0) # cancel alarm
except Alarm:
process.terminate()
finally:
# print saved lines
print ''.join(q)
if __name__=="__main__":
main()
此方法仅适用于 *NIX系统。它可能会阻止 process.stdout.readline() 不返回。
threading.Timer 解决方案
import collections
import subprocess
import threading
def main():
# start process, redirect stdout
process = subprocess.Popen(["top"], stdout=subprocess.PIPE, close_fds=True)
# terminate process in timeout seconds
timeout = 2 # seconds
timer = threading.Timer(timeout, process.terminate)
timer.start()
# save last `number_of_lines` lines of the process output
number_of_lines = 200
q = collections.deque(process.stdout, maxlen=number_of_lines)
timer.cancel()
# print saved lines
print ''.join(q),
if __name__=="__main__":
main()
这种方法也应在窗户上工作。我在这里使用过 process.stdout 作为一个帝国；它可能引入额外的输出缓冲，您可以切换到 iter(process.stdout.readline, "") 如果不是理想的话。如果该过程未终止 process.terminate() 然后脚本悬挂。
没有线程，没有信号解决方案
import collections
import subprocess
import sys
import time
def main():
args = sys.argv[1:]
if not args:
args = ['top']
# start process, redirect stdout
process = subprocess.Popen(args, stdout=subprocess.PIPE, close_fds=True)
# save last `number_of_lines` lines of the process output
number_of_lines = 200
q = collections.deque(maxlen=number_of_lines)
timeout = 2 # seconds
now = start = time.time()
while (now - start) < timeout:
line = process.stdout.readline()
if not line:
break
q.append(line)
now = time.time()
else: # on timeout
process.terminate()
# print saved lines
print ''.join(q),
if __name__=="__main__":
main()
这种变体都不使用线程，没有信号，但它会在终端中产生乱七八糟的输出。如果它会阻止 process.stdout.readline() 块。
其他提示
我不建议使用“ ps”，而不是使用“ ps”，它将为您提供相同的信息，但只能使用一次，而不是一次永恒。
您还需要使用PS的一些标志，我倾向于使用“ PS Aux”
我要做的不是这种方法是检查您试图从中获取信息并确定该信息的最终来源的程序。它可能是API调用或设备节点。然后，写一些从同一源获取的python。这消除了“刮擦”“煮熟”数据的问题和开销。
（JF Sebastian您的代码效果很好，我认为它比我的解决方案更好=）
我已经以另一种方式解决了它。
而不是直接在终端上进行输出，我将其放入文件“ tmp_file”中：
top >> tmp_file
然后，我使用工具“切割”将其输出“是最高输出”作为过程的值
cat tmp_file
它做了我想做的。这是最终代码：
import os
import subprocess
import time
subprocess.Popen("top >> tmp_file",shell = True)
time.sleep(1)
os.popen("killall top")
process = os.popen("cat tmp_file").read()
os.popen("rm tmp_file")
print process
# Thing better than nothing =)
非常感谢你们的帮助
实际上，如果填充输出缓冲区，您将以一些答案结束。因此，一种解决方案是用大型垃圾输出填充缓冲区（〜6000个字符，bufsize = 1）。
假设您有一个在sys.stdout上写的python脚本，而不是顶部：
GARBAGE='.\n'
sys.stdout.write(valuable_output)
sys.stdout.write(GARBAGE*3000)
在启动器端，而不是简单的process.readline（）：
GARBAGE='.\n'
line=process.readline()
while line==GARBAGE:
line=process.readline()
可以肯定的是，这有点脏，因为2000取决于子进程的实现，但效果很好并且非常简单。设置除bufsize = 1以外的任何东西都会使事情变得更糟。
不隶属于 StackOverflow
