50

解決方法がよくわからない小さな問題があります。最小限の例を次に示します。

私が持っているもの

scan_process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
while(some_criterium):
    line = scan_process.stdout.readline()
    some_criterium = do_something(line)

欲しいもの

scan_process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
while(some_criterium):
    line = scan_process.stdout.readline()
    if nothing_happens_after_10s:
        break
    else:
        some_criterium = do_something(line)

サブプロセスから1行を読み取り、それを使って何かをします。一定の時間間隔を過ぎても回線が到着しなかった場合、どうすれば終了できますか？

4

6 に答える 6

30

すべての答えをありがとう！

select.pollを使用して標準出力を確認するだけで、問題を解決する方法を見つけました。

import select
...
scan_process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
poll_obj = select.poll()
poll_obj.register(scan_process.stdout, select.POLLIN)
while(some_criterium and not time_limit):
    poll_result = poll_obj.poll(0)
    if poll_result:
        line = scan_process.stdout.readline()
        some_criterium = do_something(line)
    update(time_limit)
于 2012-05-25T17:42:41.880 に答える
27

これは、以下を使用して1行を読み取るためのタイムアウトを強制するポータブルソリューションですasyncio。

#!/usr/bin/env python3
import asyncio
import sys
from asyncio.subprocess import PIPE, STDOUT

async def run_command(*args, timeout=None):
    # Start child process
    # NOTE: universal_newlines parameter is not supported
    process = await asyncio.create_subprocess_exec(*args,
            stdout=PIPE, stderr=STDOUT)

    # Read line (sequence of bytes ending with b'\n') asynchronously
    while True:
        try:
            line = await asyncio.wait_for(process.stdout.readline(), timeout)
        except asyncio.TimeoutError:
            pass
        else:
            if not line: # EOF
                break
            elif do_something(line):
                continue # While some criterium is satisfied
        process.kill() # Timeout or some criterion is not satisfied
        break
    return await process.wait() # Wait for the child process to exit


if sys.platform == "win32":
    loop = asyncio.ProactorEventLoop() # For subprocess' pipes on Windows
    asyncio.set_event_loop(loop)
else:
    loop = asyncio.get_event_loop()

returncode = loop.run_until_complete(run_command("cmd", "arg 1", "arg 2",
                                                 timeout=10))
loop.close()
于 2015-12-06T06:32:03.793 に答える
13

私はPythonでもう少し一般的なものを使用しました（正しく覚えていれば、Stack Overflowの質問からもまとめましたが、どれを思い出せません）。

import thread
from threading import Timer

def run_with_timeout(timeout, default, f, *args, **kwargs):
    if not timeout:
        return f(*args, **kwargs)
    try:
        timeout_timer = Timer(timeout, thread.interrupt_main)
        timeout_timer.start()
        result = f(*args, **kwargs)
        return result
    except KeyboardInterrupt:
        return default
    finally:
        timeout_timer.cancel()

ただし、注意が必要です。これは、割り込みを使用して、指定した機能を停止します。これはすべての関数にとって良い考えではないかもしれません、そしてそれはまたあなたがタイムアウトの間にCtrl+でプログラムを閉じるのを防ぎますC（すなわちCtrl+Cはタイムアウトとして扱われます）。

これを使用して、次のように呼び出すことができます。

scan_process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
while(some_criterium):
    line = run_with_timeout(timeout, None, scan_process.stdout.readline)
    if line is None:
        break
    else:
        some_criterium = do_something(line)

しかし、それは少しやり過ぎかもしれません。私が知らないあなたのケースのためのより簡単なオプションがあると思います。

于 2012-05-25T15:04:21.970 に答える
7

Tomのソリューションは機能しますselect()が、Cイディオムでの使用はよりコンパクトですが、これはあなたの答えと同等です。

from select import select
scan_process = subprocess.Popen(command,
                                stdout=subprocess.PIPE,
                                stderr=subprocess.STDOUT,
                                bufsize=1)  # Line buffered
while some_criterium and not time_limit:
    poll_result = select([scan_process.stdout], [], [], time_limit)[0]

残りは同じです。

を参照してくださいpydoc select.select。

[注：他のいくつかの回答と同様に、これはUnix固有です。]

[注2：OPリクエストに従ってラインバッファリングを追加するように編集]

[注3：ラインバッファリングはすべての状況で信頼できるとは限らず、readline（）ブロッキングにつながる可能性があります]

于 2015-12-06T02:10:40.757 に答える
5

移植可能な解決策は、行の読み取りに時間がかかりすぎる場合に、スレッドを使用して子プロセスを強制終了することです。

#!/usr/bin/env python3
from subprocess import Popen, PIPE, STDOUT

timeout = 10
with Popen(command, stdout=PIPE, stderr=STDOUT,
           universal_newlines=True) as process:  # text mode
    # kill process in timeout seconds unless the timer is restarted
    watchdog = WatchdogTimer(timeout, callback=process.kill, daemon=True)
    watchdog.start()
    for line in process.stdout:
        # don't invoke the watcthdog callback if do_something() takes too long
        with watchdog.blocked:
            if not do_something(line):  # some criterium is not satisfied
                process.kill()
                break
            watchdog.restart()  # restart timer just before reading the next line
    watchdog.cancel()

WatchdogTimerクラスがそのようなものでthreading.Timerある場合、再起動および/またはブロックすることができます：

from threading import Event, Lock, Thread
from subprocess import Popen, PIPE, STDOUT
from time import monotonic  # use time.time or monotonic.monotonic on Python 2

class WatchdogTimer(Thread):
    """Run *callback* in *timeout* seconds unless the timer is restarted."""

    def __init__(self, timeout, callback, *args, timer=monotonic, **kwargs):
        super().__init__(**kwargs)
        self.timeout = timeout
        self.callback = callback
        self.args = args
        self.timer = timer
        self.cancelled = Event()
        self.blocked = Lock()

    def run(self):
        self.restart() # don't start timer until `.start()` is called
        # wait until timeout happens or the timer is canceled
        while not self.cancelled.wait(self.deadline - self.timer()):
            # don't test the timeout while something else holds the lock
            # allow the timer to be restarted while blocked
            with self.blocked:
                if self.deadline <= self.timer() and not self.cancelled.is_set():
                    return self.callback(*self.args)  # on timeout

    def restart(self):
        """Restart the watchdog timer."""
        self.deadline = self.timer() + self.timeout

    def cancel(self):
        self.cancelled.set()
于 2015-12-06T08:42:57.667 に答える
3

signal.alarmを使用してみてください：

#timeout.py
import signal, sys

def timeout(sig, frm):
  print "This is taking too long..."
  sys.exit(1)

signal.signal(signal.SIGALRM, timeout)
signal.alarm(10)
byte = 0

while 'IT' not in open('/dev/urandom').read(2):
  byte += 2
print "I got IT in %s byte(s)!" % byte

それが機能することを示すためのいくつかの実行：

$ python timeout.py 
This is taking too long...
$ python timeout.py 
I got IT in 4672 byte(s)!

より詳細な例については、pGuidesを参照してください。

于 2012-10-17T20:32:01.040 に答える