blocks|key|977603|text|如果你在Unix上，|type|unstyled|depth|inlineStyleRanges|entityRanges|data|977604|import+signal
++...
class+Alarm(Exception):
++++pass

def+alarm_handler(signum,+frame):
++++raise+Alarm

signal.signal(signal.SIGALRM,+alarm_handler)
signal.alarm(5*60)++#+5+minutes
try:
++++stdoutdata,+stderrdata+=+proc.communicate()
++++signal.alarm(0)++#+reset+the+alarm
except+Alarm:
++++print+"Oops,+taking+too+long!"
++++#+whatever+else|code-block|syntax|javascript|977605|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

If you're on Unix,

<pre><code>import signal
 ...
class Alarm(Exception):
 pass

def alarm_handler(signum, frame):
 raise Alarm

signal.signal(signal.SIGALRM, alarm_handler)
signal.alarm(5*60) # 5 minutes
try:
 stdoutdata, stderrdata = proc.communicate()
 signal.alarm(0) # reset the alarm
except Alarm:
 print "Oops, taking too long!"
 # whatever else
</code></pre>

blocks|key|2417803|text|我在Windows、Linux和Mac上成功地使用了杀灭过程。如果您正在使用Cygwin，您将需要OSAF的杀灭程序版本，因为否则本地的Windows进程不会被杀死。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2417804|entityMap|0|LINK|mutability|MUTABLE|url|http://benjamin.smedbergs.us/blog/2006-12-11/killableprocesspy/|1|http://svn.osafoundation.org/chandler/trunk/chandler/tools/killableprocess.py^0|Q|4|0|1D|B|1|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@$A|O|B|P|1|Q]|$A|R|B|S|1|T]]|C|$]]|$1|D|3|-4|5|6|7|U|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]|L|$5|G|H|I|C|$J|M]]]]

I've used <a href="http://benjamin.smedbergs.us/blog/2006-12-11/killableprocesspy/" rel="nofollow noreferrer">killableprocess</a> successfully on Windows, Linux and Mac. If you are using Cygwin Python, you'll need <a href="http://svn.osafoundation.org/chandler/trunk/chandler/tools/killableprocess.py" rel="nofollow noreferrer">OSAF's version of killableprocess</a> because otherwise native Windows processes won't get killed.

blocks|key|2417809|text|这是的解决方案，它是一个模块，具有适当的过程杀灭。其他方法不起作用，因为它们不使用proc.communicate()。因此，如果您有一个产生大量输出的进程，它将填充它的输出缓冲区，然后阻塞，直到从它读取某些内容为止。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2417810|from+os+import+kill
from+signal+import+alarm,+signal,+SIGALRM,+SIGKILL
from+subprocess+import+PIPE,+Popen

def+run(args,+cwd+=+None,+shell+=+False,+kill_tree+=+True,+timeout+=+-1,+env+=+None):
++++'''
++++Run+a+command+with+a+timeout+after+which+it+will+be+forcibly
++++killed.
++++'''
++++class+Alarm(Exception):
++++++++pass
++++def+alarm_handler(signum,+frame):
++++++++raise+Alarm
++++p+=+Popen(args,+shell+=+shell,+cwd+=+cwd,+stdout+=+PIPE,+stderr+=+PIPE,+env+=+env)
++++if+timeout+!=+-1:
++++++++signal(SIGALRM,+alarm_handler)
++++++++alarm(timeout)
++++try:
++++++++stdout,+stderr+=+p.communicate()
++++++++if+timeout+!=+-1:
++++++++++++alarm(0)
++++except+Alarm:
++++++++pids+=+[p.pid]
++++++++if+kill_tree:
++++++++++++pids.extend(get_process_children(p.pid))
++++++++for+pid+in+pids:
++++++++++++#+process+might+have+died+before+getting+to+this+line
++++++++++++#+so+wrap+to+avoid+OSError:+no+such+process
++++++++++++try:+
++++++++++++++++kill(pid,+SIGKILL)
++++++++++++except+OSError:
++++++++++++++++pass
++++++++return+-9,+'',+''
++++return+p.returncode,+stdout,+stderr

def+get_process_children(pid):
++++p+=+Popen('ps+--no-headers+-o+pid+--ppid+%25d'+%25+pid,+shell+=+True,
++++++++++++++stdout+=+PIPE,+stderr+=+PIPE)
++++stdout,+stderr+=+p.communicate()
++++return+[int(p)+for+p+in+stdout.split()]

if+__name__+==+'__main__':
++++print+run('find+/',+shell+=+True,+timeout+=+3)
++++print+run('find',+shell+=+True)|code-block|syntax|javascript|2417811|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here is Alex Martelli's solution as a module with proper process killing. The other approaches do not work because they do not use proc.communicate(). So if you have a process that produces lots of output, it will fill its output buffer and then block until you read something from it.

<pre><code>from os import kill
from signal import alarm, signal, SIGALRM, SIGKILL
from subprocess import PIPE, Popen

def run(args, cwd = None, shell = False, kill_tree = True, timeout = -1, env = None):
 '''
 Run a command with a timeout after which it will be forcibly
 killed.
 '''
 class Alarm(Exception):
 pass
 def alarm_handler(signum, frame):
 raise Alarm
 p = Popen(args, shell = shell, cwd = cwd, stdout = PIPE, stderr = PIPE, env = env)
 if timeout != -1:
 signal(SIGALRM, alarm_handler)
 alarm(timeout)
 try:
 stdout, stderr = p.communicate()
 if timeout != -1:
 alarm(0)
 except Alarm:
 pids = [p.pid]
 if kill_tree:
 pids.extend(get_process_children(p.pid))
 for pid in pids:
 # process might have died before getting to this line
 # so wrap to avoid OSError: no such process
 try: 
 kill(pid, SIGKILL)
 except OSError:
 pass
 return -9, '', ''
 return p.returncode, stdout, stderr

def get_process_children(pid):
 p = Popen('ps --no-headers -o pid --ppid %d' % pid, shell = True,
 stdout = PIPE, stderr = PIPE)
 stdout, stderr = p.communicate()
 return [int(p) for p in stdout.split()]

if __name__ == '__main__':
 print run('find /', shell = True, timeout = 3)
 print run('find', shell = True)
</code></pre>

blocks|key|2417841|text|另一种选择是向临时文件写入，以防止stdout阻塞，而不需要使用communicate()轮询。在其他答案没有的情况下，这对我起了作用；例如在窗户上。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2417842|++++outFile+=++tempfile.SpooledTemporaryFile()+
++++errFile+=+++tempfile.SpooledTemporaryFile()+
++++proc+=+subprocess.Popen(args,+stderr=errFile,+stdout=outFile,+universal_newlines=False)
++++wait_remaining_sec+=+timeout

++++while+proc.poll()+is+None+and+wait_remaining_sec+>+0:
++++++++time.sleep(1)
++++++++wait_remaining_sec+-=+1

++++if+wait_remaining_sec+<=+0:
++++++++killProc(proc.pid)
++++++++raise+ProcessIncompleteError(proc,+timeout)

++++#+read+temp+streams+from+start
++++outFile.seek(0);
++++errFile.seek(0);
++++out+=+outFile.read()
++++err+=+errFile.read()
++++outFile.close()
++++errFile.close()|code-block|syntax|javascript|2417843|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Another option is to write to a temporary file to prevent the stdout blocking instead of needing to poll with communicate(). This worked for me where the other answers did not; for example on windows.

<pre><code> outFile = tempfile.SpooledTemporaryFile() 
 errFile = tempfile.SpooledTemporaryFile() 
 proc = subprocess.Popen(args, stderr=errFile, stdout=outFile, universal_newlines=False)
 wait_remaining_sec = timeout

 while proc.poll() is None and wait_remaining_sec &gt; 0:
 time.sleep(1)
 wait_remaining_sec -= 1

 if wait_remaining_sec &lt;= 0:
 killProc(proc.pid)
 raise ProcessIncompleteError(proc, timeout)

 # read temp streams from start
 outFile.seek(0);
 errFile.seek(0);
 out = outFile.read()
 err = errFile.read()
 outFile.close()
 errFile.close()
</code></pre>

blocks|key|891890|text|我不太了解底层的细节；但是，考虑到在python2.6中API提供了等待线程和终止进程的能力，那么在单独的线程中运行进程会怎么样呢？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|891891|import+subprocess,+threading

class+Command(object):
++++def+__init__(self,+cmd):
++++++++self.cmd+=+cmd
++++++++self.process+=+None

++++def+run(self,+timeout):
++++++++def+target():
++++++++++++print+'Thread+started'
++++++++++++self.process+=+subprocess.Popen(self.cmd,+shell=True)
++++++++++++self.process.communicate()
++++++++++++print+'Thread+finished'

++++++++thread+=+threading.Thread(target=target)
++++++++thread.start()

++++++++thread.join(timeout)
++++++++if+thread.is_alive():
++++++++++++print+'Terminating+process'
++++++++++++self.process.terminate()
++++++++++++thread.join()
++++++++print+self.process.returncode

command+=+Command("echo+'Process+started';+sleep+2;+echo+'Process+finished'")
command.run(timeout=3)
command.run(timeout=1)|code-block|syntax|javascript|891892|在我的机器中，这个片段的输出是：|891893|Thread+started
Process+started
Process+finished
Thread+finished
0
Thread+started
Process+started
Terminating+process
Thread+finished
-15|891894|可以看到，在第一次执行中，进程正确地完成了(返回代码0)，而在第二次执行中，进程被终止(返回代码-15)。|891895|我还没有在windows中进行测试；但是，除了更新示例命令之外，我认为它应该可以工作，因为我还没有在文档中找到任何表明不支持thread.join或process.terminate的内容。|891896|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

I don't know much about the low level details; but, given that in
python 2.6 the API offers the ability to wait for threads and
terminate processes, what about running the process in a separate
thread?

<pre><code>import subprocess, threading

class Command(object):
 def __init__(self, cmd):
 self.cmd = cmd
 self.process = None

 def run(self, timeout):
 def target():
 print 'Thread started'
 self.process = subprocess.Popen(self.cmd, shell=True)
 self.process.communicate()
 print 'Thread finished'

 thread = threading.Thread(target=target)
 thread.start()

 thread.join(timeout)
 if thread.is_alive():
 print 'Terminating process'
 self.process.terminate()
 thread.join()
 print self.process.returncode

command = Command("echo 'Process started'; sleep 2; echo 'Process finished'")
command.run(timeout=3)
command.run(timeout=1)
</code></pre>

The output of this snippet in my machine is:

<pre><code>Thread started
Process started
Process finished
Thread finished
0
Thread started
Process started
Terminating process
Thread finished
-15
</code></pre>

where it can be seen that, in the first execution, the process
finished correctly (return code 0), while the in the second one the
process was terminated (return code -15).

I haven't tested in windows; but, aside from updating the example
command, I think it should work since I haven't found in the
documentation anything that says that thread.join or process.terminate
is not supported.

blocks|key|977671|text|我已经实现了我可以从其中几个中收集到的东西。因为这是一个社区wiki，所以我想我也会分享我的代码：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|977672|class+Command(threading.Thread):
++++def+__init__(self,+cmd,+outFile,+errFile,+timeout):
++++++++threading.Thread.__init__(self)
++++++++self.cmd+=+cmd
++++++++self.process+=+None
++++++++self.outFile+=+outFile
++++++++self.errFile+=+errFile
++++++++self.timed_out+=+False
++++++++self.timeout+=+timeout

++++def+run(self):
++++++++self.process+=+subprocess.Popen(self.cmd,+stdout+=+self.outFile,+\
++++++++++++stderr+=+self.errFile)

++++++++while+(self.process.poll()+is+None+and+self.timeout+>+0):
++++++++++++time.sleep(1)
++++++++++++self.timeout+-=+1

++++++++if+not+self.timeout+>+0:
++++++++++++self.process.terminate()
++++++++++++self.timed_out+=+True
++++++++else:
++++++++++++self.timed_out+=+False|code-block|syntax|javascript|977673|然后从另一个类或文件：|977674|++++++++outFile+=++tempfile.SpooledTemporaryFile()
++++++++errFile+=+++tempfile.SpooledTemporaryFile()

++++++++executor+=+command.Command(c,+outFile,+errFile,+timeout)
++++++++executor.daemon+=+True
++++++++executor.start()

++++++++executor.join()
++++++++if+executor.timed_out:
++++++++++++out+=+'timed+out'
++++++++else:
++++++++++++outFile.seek(0)
++++++++++++errFile.seek(0)
++++++++++++out+=+outFile.read()
++++++++++++err+=+errFile.read()

++++++++outFile.close()
++++++++errFile.close()|977675|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

I've implemented what I could gather from a few of these. This works in Windows, and since this is a community wiki, I figure I would share my code as well:

<pre><code>class Command(threading.Thread):
 def __init__(self, cmd, outFile, errFile, timeout):
 threading.Thread.__init__(self)
 self.cmd = cmd
 self.process = None
 self.outFile = outFile
 self.errFile = errFile
 self.timed_out = False
 self.timeout = timeout

 def run(self):
 self.process = subprocess.Popen(self.cmd, stdout = self.outFile, \
 stderr = self.errFile)

 while (self.process.poll() is None and self.timeout &gt; 0):
 time.sleep(1)
 self.timeout -= 1

 if not self.timeout &gt; 0:
 self.process.terminate()
 self.timed_out = True
 else:
 self.timed_out = False
</code></pre>

Then from another class or file:

<pre><code> outFile = tempfile.SpooledTemporaryFile()
 errFile = tempfile.SpooledTemporaryFile()

 executor = command.Command(c, outFile, errFile, timeout)
 executor.daemon = True
 executor.start()

 executor.join()
 if executor.timed_out:
 out = 'timed out'
 else:
 outFile.seek(0)
 errFile.seek(0)
 out = outFile.read()
 err = errFile.read()

 outFile.close()
 errFile.close()
</code></pre>

blocks|key|977088|text|我将jcollado线程的解决方案添加到Python模块易处理中。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|977089|安装：|977090|pip+install+easyprocess|code-block|syntax|javascript|977091|示例：|977092|from+easyprocess+import+Proc

#+shell+is+not+supported!
stdout=Proc('ping+localhost').call(timeout=1.5).stdout
print+stdout|977093|entityMap|0|LINK|mutability|MUTABLE|url|http://code.activestate.com/pypm/easyprocess/^0|2|8|S|3|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@$9|Z|A|10|B|C]]|D|@$9|11|A|12|1|13]]|E|$]]|$1|F|3|G|5|6|7|14|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|15|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|16|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|17|8|@]|D|@]|E|$K|L]]|$1|Q|3|-4|5|6|7|18|8|@]|D|@]|E|$]]]|R|$S|$5|T|U|V|E|$W|X]]]]

I added the solution with threading from <code>jcollado</code> to my Python module <a href="http://code.activestate.com/pypm/easyprocess/" rel="noreferrer">easyprocess</a>.

Install:

<pre><code>pip install easyprocess
</code></pre>

Example:

<pre><code>from easyprocess import Proc

# shell is not supported!
stdout=Proc('ping localhost').call(timeout=1.5).stdout
print stdout
</code></pre>

blocks|key|977708|text|虽然我还没有详细地研究过它，但我在ActiveState上找到的这个ActiveState似乎对这类事情非常有用。和subprocess.Popen(...,+close_fds=True)一起，至少我已经准备好用Python编写shell脚本了。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|977709|entityMap^0|1M|11|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

Although I haven't looked at it extensively, this <a href="http://code.activestate.com/recipes/307871-timing-out-function/" rel="nofollow">decorator</a> I found at ActiveState seems to be quite useful for this sort of thing. Along with <code>subprocess.Popen(..., close_fds=True)</code>, at least I'm ready for shell-scripting in Python.

blocks|key|2418037|text|我使用的解决方案是以时间限制作为shell命令的前缀。如果comand花费太长时间，timelimit将停止它，Popen将有一个由timelimit设置的返回代码。如果是>+128，就意味着时间限制终止了这个过程。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2418038|另见python+subprocess+with+timeout+and+large+output+(>64K)|2418039|entityMap|0|LINK|mutability|MUTABLE|url|http://devel.ringlet.net/sysutils/timelimit/|1|https://stackoverflow.com/questions/3575554/python-subprocess-with-timeout-and-large-output-64k^0|A|4|0|0|2|1I|1|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@$A|Q|B|R|1|S]]|C|$]]|$1|D|3|E|5|6|7|T|8|@]|9|@$A|U|B|V|1|W]]|C|$]]|$1|F|3|-4|5|6|7|X|8|@]|9|@]|C|$]]]|G|$H|$5|I|J|K|C|$L|M]]|N|$5|I|J|K|C|$L|O]]]]

The solution I use is to prefix the shell command with <a href="http://devel.ringlet.net/sysutils/timelimit/" rel="nofollow noreferrer">timelimit</a>. If the comand takes too long, timelimit will stop it and Popen will have a returncode set by timelimit. If it is > 128, it means timelimit killed the process.

See also <a href="https://stackoverflow.com/questions/3575554/python-subprocess-with-timeout-and-large-output-64k">python subprocess with timeout and large output (&gt;64K)</a>

blocks|key|892064|text|jcollado的答案可以使用threading.Timer类进行简化：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|892065|import+shlex
from+subprocess+import+Popen,+PIPE
from+threading+import+Timer

def+run(cmd,+timeout_sec):
++++proc+=+Popen(shlex.split(cmd),+stdout=PIPE,+stderr=PIPE)
++++timer+=+Timer(timeout_sec,+proc.kill)
++++try:
++++++++timer.start()
++++++++stdout,+stderr+=+proc.communicate()
++++finally:
++++++++timer.cancel()

#+Examples:+both+take+1+second
run("sleep+1",+5)++#+process+ends+normally+at+1+second
run("sleep+5",+1)++#+timeout+happens+at+1+second|code-block|syntax|javascript|892066|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.python.org/library/threading.html#threading.Timer^0|F|F|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

jcollado's answer can be simplified using the <a href="https://docs.python.org/library/threading.html#threading.Timer" rel="noreferrer">threading.Timer</a> class:
<pre><code>import shlex
from subprocess import Popen, PIPE
from threading import Timer

def run(cmd, timeout_sec):
 proc = Popen(shlex.split(cmd), stdout=PIPE, stderr=PIPE)
 timer = Timer(timeout_sec, proc.kill)
 try:
 timer.start()
 stdout, stderr = proc.communicate()
 finally:
 timer.cancel()

# Examples: both take 1 second
run(&quot;sleep 1&quot;, 5) # process ends normally at 1 second
run(&quot;sleep 5&quot;, 1) # timeout happens at 1 second
</code></pre>

blocks|key|2418112|text|一旦您了解了在*unix中运行机器的全过程，您将很容易找到更简单的解决方案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2418113|考虑一下这个简单的例子，如何使用select.select()+(在*nix上的几乎所有可用的)实现timeoutable通信()方法。这也可以用epoll/poll/kqueue编写，但是select.select()变体可能是一个很好的例子。select.select()的主要限制(速度和1024最大fds)不适用于您的任务。|2418114|它在*nix下工作，不创建线程，不使用信号，可以从任何线程(不仅仅是主线程)中读取，并且可以快速读取我的机器上的stdout中的250+my+/s数据(i5+2.3ghz)。|2418115|在通信结束时加入stdout/stderr有一个问题。如果您有大量的程序输出，这可能会导致内存的大量使用。但是，您可以使用较小的超时来多次调用communicate()。|2418116|class+Popen(subprocess.Popen):
++++def+communicate(self,+input=None,+timeout=None):
++++++++if+timeout+is+None:
++++++++++++return+subprocess.Popen.communicate(self,+input)

++++++++if+self.stdin:
++++++++++++#+Flush+stdio+buffer,+this+might+block+if+user
++++++++++++#+has+been+writing+to+.stdin+in+an+uncontrolled
++++++++++++#+fashion.
++++++++++++self.stdin.flush()
++++++++++++if+not+input:
++++++++++++++++self.stdin.close()

++++++++read_set,+write_set+=+[],+[]
++++++++stdout+=+stderr+=+None

++++++++if+self.stdin+and+input:
++++++++++++write_set.append(self.stdin)
++++++++if+self.stdout:
++++++++++++read_set.append(self.stdout)
++++++++++++stdout+=+[]
++++++++if+self.stderr:
++++++++++++read_set.append(self.stderr)
++++++++++++stderr+=+[]

++++++++input_offset+=+0
++++++++deadline+=+time.time()+%2B+timeout

++++++++while+read_set+or+write_set:
++++++++++++try:
++++++++++++++++rlist,+wlist,+xlist+=+select.select(read_set,+write_set,+[],+max(0,+deadline+-+time.time()))
++++++++++++except+select.error+as+ex:
++++++++++++++++if+ex.args[0]+==+errno.EINTR:
++++++++++++++++++++continue
++++++++++++++++raise

++++++++++++if+not+(rlist+or+wlist):
++++++++++++++++#+Just+break+if+timeout
++++++++++++++++#+Since+we+do+not+close+stdout/stderr/stdin,+we+can+call
++++++++++++++++#+communicate()+several+times+reading+data+by+smaller+pieces.
++++++++++++++++break

++++++++++++if+self.stdin+in+wlist:
++++++++++++++++chunk+=+input[input_offset:input_offset+%2B+subprocess._PIPE_BUF]
++++++++++++++++try:
++++++++++++++++++++bytes_written+=+os.write(self.stdin.fileno(),+chunk)
++++++++++++++++except+OSError+as+ex:
++++++++++++++++++++if+ex.errno+==+errno.EPIPE:
++++++++++++++++++++++++self.stdin.close()
++++++++++++++++++++++++write_set.remove(self.stdin)
++++++++++++++++++++else:
++++++++++++++++++++++++raise
++++++++++++++++else:
++++++++++++++++++++input_offset+%2B=+bytes_written
++++++++++++++++++++if+input_offset+>=+len(input):
++++++++++++++++++++++++self.stdin.close()
++++++++++++++++++++++++write_set.remove(self.stdin)

++++++++++++#+Read+stdout+/+stderr+by+1024+bytes
++++++++++++for+fn,+tgt+in+(
++++++++++++++++(self.stdout,+stdout),
++++++++++++++++(self.stderr,+stderr),
++++++++++++):
++++++++++++++++if+fn+in+rlist:
++++++++++++++++++++data+=+os.read(fn.fileno(),+1024)
++++++++++++++++++++if+data+==+'':
++++++++++++++++++++++++fn.close()
++++++++++++++++++++++++read_set.remove(fn)
++++++++++++++++++++tgt.append(data)

++++++++if+stdout+is+not+None:
++++++++++++stdout+=+''.join(stdout)
++++++++if+stderr+is+not+None:
++++++++++++stderr+=+''.join(stderr)

++++++++return+(stdout,+stderr)|code-block|syntax|javascript|2418117|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|Q|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|R|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|S|8|@]|9|@]|A|$K|L]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Once you understand full process running machinery in *unix, you will easily find simplier solution:

Consider this simple example how to make timeoutable communicate() meth using select.select() (available alsmost everythere on *nix nowadays). This also can be written with epoll/poll/kqueue, but select.select() variant could be a good example for you. And major limitations of select.select() (speed and 1024 max fds) are not applicapable for your task.

This works under *nix, does not create threads, does not uses signals, can be lauched from any thread (not only main), and fast enought to read 250mb/s of data from stdout on my machine (i5 2.3ghz).

There is a problem in join'ing stdout/stderr at the end of communicate. If you have huge program output this could lead to big memory usage. But you can call communicate() several times with smaller timeouts.

<pre><code>class Popen(subprocess.Popen):
 def communicate(self, input=None, timeout=None):
 if timeout is None:
 return subprocess.Popen.communicate(self, input)

 if self.stdin:
 # Flush stdio buffer, this might block if user
 # has been writing to .stdin in an uncontrolled
 # fashion.
 self.stdin.flush()
 if not input:
 self.stdin.close()

 read_set, write_set = [], []
 stdout = stderr = None

 if self.stdin and input:
 write_set.append(self.stdin)
 if self.stdout:
 read_set.append(self.stdout)
 stdout = []
 if self.stderr:
 read_set.append(self.stderr)
 stderr = []

 input_offset = 0
 deadline = time.time() + timeout

 while read_set or write_set:
 try:
 rlist, wlist, xlist = select.select(read_set, write_set, [], max(0, deadline - time.time()))
 except select.error as ex:
 if ex.args[0] == errno.EINTR:
 continue
 raise

 if not (rlist or wlist):
 # Just break if timeout
 # Since we do not close stdout/stderr/stdin, we can call
 # communicate() several times reading data by smaller pieces.
 break

 if self.stdin in wlist:
 chunk = input[input_offset:input_offset + subprocess._PIPE_BUF]
 try:
 bytes_written = os.write(self.stdin.fileno(), chunk)
 except OSError as ex:
 if ex.errno == errno.EPIPE:
 self.stdin.close()
 write_set.remove(self.stdin)
 else:
 raise
 else:
 input_offset += bytes_written
 if input_offset &gt;= len(input):
 self.stdin.close()
 write_set.remove(self.stdin)

 # Read stdout / stderr by 1024 bytes
 for fn, tgt in (
 (self.stdout, stdout),
 (self.stderr, stderr),
 ):
 if fn in rlist:
 data = os.read(fn.fileno(), 1024)
 if data == '':
 fn.close()
 read_set.remove(fn)
 tgt.append(data)

 if stdout is not None:
 stdout = ''.join(stdout)
 if stderr is not None:
 stderr = ''.join(stderr)

 return (stdout, stderr)
</code></pre>

blocks|key|977159|text|我修改了sussudio的答案。现在函数返回：(returncode，stdout，stderr，timeout)+-+stdout和stderr被解码为utf-8字符串。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|CODE|entityRanges|data|977160|def+kill_proc(proc,+timeout):
++timeout["value"]+=+True
++proc.kill()

def+run(cmd,+timeout_sec):
++proc+=+subprocess.Popen(shlex.split(cmd),+stdout=subprocess.PIPE,+stderr=subprocess.PIPE)
++timeout+=+{"value":+False}
++timer+=+Timer(timeout_sec,+kill_proc,+[proc,+timeout])
++timer.start()
++stdout,+stderr+=+proc.communicate()
++timer.cancel()
++return+proc.returncode,+stdout.decode("utf-8"),+stderr.decode("utf-8"),+timeout["value"]|code-block|syntax|javascript|977161|entityMap^0|4|8|O|A|Z|6|16|6|1D|7|1O|6|1V|6|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@$9|O|A|P|B|C]|$9|Q|A|R|B|D]|$9|S|A|T|B|D]|$9|U|A|V|B|D]|$9|W|A|X|B|D]|$9|Y|A|Z|B|D]|$9|10|A|11|B|D]]|E|@]|F|$]]|$1|G|3|H|5|I|7|12|8|@]|E|@]|F|$J|K]]|$1|L|3|-4|5|6|7|13|8|@]|E|@]|F|$]]]|M|$]]

I've modified sussudio answer. Now function returns: (<code>returncode</code>, <code>stdout</code>, <code>stderr</code>, <code>timeout</code>) - <code>stdout</code> and <code>stderr</code> is decoded to utf-8 string

<pre><code>def kill_proc(proc, timeout):
 timeout["value"] = True
 proc.kill()

def run(cmd, timeout_sec):
 proc = subprocess.Popen(shlex.split(cmd), stdout=subprocess.PIPE, stderr=subprocess.PIPE)
 timeout = {"value": False}
 timer = Timer(timeout_sec, kill_proc, [proc, timeout])
 timer.start()
 stdout, stderr = proc.communicate()
 timer.cancel()
 return proc.returncode, stdout.decode("utf-8"), stderr.decode("utf-8"), timeout["value"]
</code></pre>

blocks|key|892168|text|不幸的是，我受到雇主对源代码披露的严格政策的约束，所以我无法提供实际的代码。但就我的口味而言，最好的解决方案是创建一个子类来覆盖Popen.wait()来轮询，而不是无限期地等待，并创建一个Popen.__init__来接受一个超时参数。一旦您这样做，所有其他Popen方法(调用wait)都将按预期工作，包括communicate。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|892169|entityMap^0|1S|C|2N|E|3M|5|3W|4|4B|B|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]|$9|M|A|N|B|C]|$9|O|A|P|B|C]|$9|Q|A|R|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|S|8|@]|D|@]|E|$]]]|G|$]]

Unfortunately, I'm bound by very strict policies on the disclosure of source code by my employer, so I can't provide actual code. But for my taste the best solution is to create a subclass overriding <code>Popen.wait()</code> to poll instead of wait indefinitely, and <code>Popen.__init__</code> to accept a timeout parameter. Once you do that, all the other <code>Popen</code> methods (which call <code>wait</code>) will work as expected, including <code>communicate</code>.

blocks|key|2418190|text|在Python+3.3%2B中：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2418191|from+subprocess+import+STDOUT,+check_output

output+=+check_output(cmd,+stderr=STDOUT,+timeout=seconds)|code-block|syntax|javascript|2418192|output是一个字节字符串，包含命令的合并的stdout、stderr数据。|offset|length|style|CODE|2418193|check_output在问题的文本中指定的非零退出状态下引发CalledProcessError，这与proc.communicate()方法不同。|2418194|我删除了shell=True，因为它经常被不必要地使用。如果cmd确实需要它，则始终可以将其添加回。如果添加shell=True，即，如果子进程产生自己的后代；check_output()返回的时间可能比超时所指示的要晚得多，请参见子进程超时故障。|2418195|在Python2.x上可以通过subprocess32子进程模块的3.2%2B后端端口获得超时特性。|2418196|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.python.org/3/library/subprocess.html#subprocess.check_output|1|https://stackoverflow.com/q/36952245/4279|2|http://pypi.python.org/pypi/subprocess32/^0|0|0|0|6|0|0|C|V|I|1G|I|0|C|0|0|4|A|U|3|1I|A|28|E|38|7|1|0|F|C|F|C|2|0^^$0|@$1|2|3|4|5|6|7|14|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|15|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|16|8|@$I|17|J|18|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|19|8|@$I|1A|J|1B|K|L]|$I|1C|J|1D|K|L]|$I|1E|J|1F|K|L]]|9|@$I|1G|J|1H|1|1I]]|A|$]]|$1|O|3|P|5|6|7|1J|8|@$I|1K|J|1L|K|L]|$I|1M|J|1N|K|L]|$I|1O|J|1P|K|L]|$I|1Q|J|1R|K|L]]|9|@$I|1S|J|1T|1|1U]]|A|$]]|$1|Q|3|R|5|6|7|1V|8|@$I|1W|J|1X|K|L]]|9|@$I|1Y|J|1Z|1|20]]|A|$]]|$1|S|3|-4|5|6|7|21|8|@]|9|@]|A|$]]]|T|$U|$5|V|W|X|A|$Y|Z]]|10|$5|V|W|X|A|$Y|11]]|12|$5|V|W|X|A|$Y|13]]]]

In Python 3.3+:

<pre><code>from subprocess import STDOUT, check_output

output = check_output(cmd, stderr=STDOUT, timeout=seconds)
</code></pre>

<code>output</code> is a byte string that contains command's merged stdout, stderr data. 

<a href="https://docs.python.org/3/library/subprocess.html#subprocess.check_output" rel="noreferrer"><code>check_output</code></a> raises <code>CalledProcessError</code> on non-zero exit status as specified in the question's text unlike <code>proc.communicate()</code> method.

I've removed <code>shell=True</code> because it is often used unnecessarily. You can always add it back if <code>cmd</code> indeed requires it. If you add <code>shell=True</code> i.e., if the child process spawns its own descendants; <code>check_output()</code> can return much later than the timeout indicates, see <a href="https://stackoverflow.com/q/36952245/4279">Subprocess timeout failure</a>.

The timeout feature is available on Python 2.x via the <a href="http://pypi.python.org/pypi/subprocess32/" rel="noreferrer"><code>subprocess32</code></a> backport of the 3.2+ subprocess module.

blocks|key|2418211|text|只是想写些更简单的东西。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2418212|#!/usr/bin/python

from+subprocess+import+Popen,+PIPE
import+datetime
import+time+

popen+=+Popen(["/bin/sleep",+"10"]);
pid+=+popen.pid
sttime+=+time.time();
waittime+=++3

print+"Start+time+%25s"%25(sttime)

while+True:
++++popen.poll();
++++time.sleep(1)
++++rcode+=+popen.returncode
++++now+=+time.time();
++++if+[+rcode+is+None+]++and++[+now+>+(sttime+%2B+waittime)+]+:
++++++++print+"Killing+it+now"
++++++++popen.kill()|code-block|syntax|javascript|2418213|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Was just trying to write something simpler.

<pre><code>#!/usr/bin/python

from subprocess import Popen, PIPE
import datetime
import time 

popen = Popen(["/bin/sleep", "10"]);
pid = popen.pid
sttime = time.time();
waittime = 3

print "Start time %s"%(sttime)

while True:
 popen.poll();
 time.sleep(1)
 rcode = popen.returncode
 now = time.time();
 if [ rcode is None ] and [ now &gt; (sttime + waittime) ] :
 print "Killing it now"
 popen.kill()
</code></pre>

blocks|key|2418228|text|这是我的解决方案，我使用了线程和事件：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2418229|import+subprocess
from+threading+import+Thread,+Event

def+kill_on_timeout(done,+timeout,+proc):
++++if+not+done.wait(timeout):
++++++++proc.kill()

def+exec_command(command,+timeout):

++++done+=+Event()
++++proc+=+subprocess.Popen(command,+stdout=subprocess.PIPE,+stderr=subprocess.PIPE)

++++watcher+=+Thread(target=kill_on_timeout,+args=(done,+timeout,+proc))
++++watcher.daemon+=+True
++++watcher.start()

++++data,+stderr+=+proc.communicate()
++++done.set()

++++return+data,+stderr,+proc.returncode|code-block|syntax|javascript|2418230|在行动中：|2418231|In+[2]:+exec_command(['sleep',+'10'],+5)
Out[2]:+('',+'',+-9)

In+[3]:+exec_command(['sleep',+'10'],+11)
Out[3]:+('',+'',+0)|2418232|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Here is my solution, I was using Thread and Event:

<pre><code>import subprocess
from threading import Thread, Event

def kill_on_timeout(done, timeout, proc):
 if not done.wait(timeout):
 proc.kill()

def exec_command(command, timeout):

 done = Event()
 proc = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE)

 watcher = Thread(target=kill_on_timeout, args=(done, timeout, proc))
 watcher.daemon = True
 watcher.start()

 data, stderr = proc.communicate()
 done.set()

 return data, stderr, proc.returncode
</code></pre>

In action:

<pre><code>In [2]: exec_command(['sleep', '10'], 5)
Out[2]: ('', '', -9)

In [3]: exec_command(['sleep', '10'], 11)
Out[3]: ('', '', 0)
</code></pre>

blocks|key|892276|text|现在支持由call()和communicate()在子流程模块中进行(从Python3.3开始)：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|892277|import+subprocess

subprocess.call("command",+timeout=20,+shell=True)|code-block|syntax|javascript|892278|这将调用命令并引发异常。|892279|subprocess.TimeoutExpired|892280|如果命令在20秒后仍未完成。|892281|然后您可以处理异常以继续您的代码，如下所示：|892282|try:
++++subprocess.call("command",+timeout=20,+shell=True)
except+subprocess.TimeoutExpired:
++++#+insert+code+here|892283|希望这能有所帮助。|892284|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.python.org/3/library/subprocess.html#subprocess.call^0|5|6|C|D|0|4|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@$9|15|A|16|B|C]|$9|17|A|18|B|C]]|D|@$9|19|A|1A|1|1B]]|E|$]]|$1|F|3|G|5|H|7|1C|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|1D|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|1E|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|1F|8|@]|D|@]|E|$]]|$1|Q|3|R|5|6|7|1G|8|@]|D|@]|E|$]]|$1|S|3|T|5|H|7|1H|8|@]|D|@]|E|$I|J]]|$1|U|3|V|5|6|7|1I|8|@]|D|@]|E|$]]|$1|W|3|-4|5|6|7|1J|8|@]|D|@]|E|$]]]|X|$Y|$5|Z|10|11|E|$12|13]]]]

<a href="https://docs.python.org/3/library/subprocess.html#subprocess.call" rel="noreferrer"><code>timeout</code> is now supported</a> by <code>call()</code> and <code>communicate()</code> in the subprocess module (as of Python3.3):

<pre><code>import subprocess

subprocess.call("command", timeout=20, shell=True)
</code></pre>

This will call the command and raise the exception

<pre><code>subprocess.TimeoutExpired
</code></pre>

if the command doesn't finish after 20 seconds.

You can then handle the exception to continue your code, something like:

<pre><code>try:
 subprocess.call("command", timeout=20, shell=True)
except subprocess.TimeoutExpired:
 # insert code here
</code></pre>

Hope this helps.

blocks|key|977228|text|令人惊讶的是没有人提到使用timeout|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|977229|timeout+5+ping+-c+3+somehost|977230|显然，这并不适用于每个用例，但是如果您处理的是一个简单的脚本，这是很难克服的。|977231|还可以通过homebrew为mac用户提供核心功能中的gtimeout。|977232|entityMap^0|D|7|0|0|S|0|0|5|8|0^^$0|@$1|2|3|4|5|6|7|N|8|@$9|O|A|P|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|T|8|@]|D|@]|E|$]]|$1|J|3|K|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@]|E|$]]|$1|L|3|-4|5|6|7|X|8|@]|D|@]|E|$]]]|M|$]]

surprised nobody mentioned using <code>timeout</code>

<code>timeout 5 ping -c 3 somehost</code>

This won't for work for every use case obviously, but if your dealing with a simple script, this is hard to beat.

Also available as gtimeout in coreutils via <code>homebrew</code> for mac users.

blocks|key|892351|text|https://pypi.python.org/pypi/python-subprocess2提供了对子流程模块的扩展，允许您等待一段时间，否则就会终止。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|892352|因此，若要等待进程终止最多10秒，否则将终止：|892353|pipe++=+subprocess.Popen('...')

timeout+=++10

results+=+pipe.waitOrTerminate(timeout)|code-block|syntax|javascript|892354|这与windows和unix兼容。"returnCode“是一本字典，它包含"actionTaken”(这是应用程序的返回)(如果必须删除，则不返回)，以及“actionTaken”。如果过程正常完成，它将是"SUBPROCESS2_PROCESS_COMPLETED“，或者是"SUBPROCESS2_PROCESS_TERMINATED”和SUBPROCESS2_PROCESS_KILLED的掩码，这取决于所采取的行动(详见文档)。|892355|entityMap|0|LINK|mutability|MUTABLE|url|https://pypi.python.org/pypi/python-subprocess2^0|0|1B|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|6|7|Y|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|Z|8|@]|9|@]|C|$I|J]]|$1|K|3|L|5|6|7|10|8|@]|9|@]|C|$]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]]]

<a href="https://pypi.python.org/pypi/python-subprocess2" rel="nofollow">https://pypi.python.org/pypi/python-subprocess2</a> provides extensions to the subprocess module which allow you to wait up to a certain period of time, otherwise terminate. 

So, to wait up to 10 seconds for the process to terminate, otherwise kill:

<pre><code>pipe = subprocess.Popen('...')

timeout = 10

results = pipe.waitOrTerminate(timeout)
</code></pre>

This is compatible with both windows and unix. "results" is a dictionary, it contains "returnCode" which is the return of the app (or None if it had to be killed), as well as "actionTaken". which will be "SUBPROCESS2_PROCESS_COMPLETED" if the process completed normally, or a mask of "SUBPROCESS2_PROCESS_TERMINATED" and SUBPROCESS2_PROCESS_KILLED depending on action taken (see documentation for full details)

blocks|key|2418309|text|如果您正在使用python+2，请尝试一下。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2418310|import+subprocess32

try:
++++output+=+subprocess32.check_output(command,+shell=True,+timeout=3)
except+subprocess32.TimeoutExpired+as+e:
++++print+e|code-block|syntax|javascript|2418311|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

if you are using python 2, give it a try

<pre><code>import subprocess32

try:
 output = subprocess32.check_output(command, shell=True, timeout=3)
except subprocess32.TimeoutExpired as e:
 print e
</code></pre>

blocks|key|977878|text|该解决方案在发生shell=True的情况下杀死进程树，将参数传递给进程(或不传递)，具有超时，并获取回调的stdout、stderr和进程输出(kill_proc_tree使用psutil+)。这是基于几个解决方案张贴在其中，包括jcollado的。张贴回应的评论，由Anson和jradice在jcollado的答复。在Windows+2012和Ubuntu+14.04中进行了测试。请注意，对于Ubuntu，您需要更改parent.children(.)呼叫parent.get_children(.)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|977879|def+kill_proc_tree(pid,+including_parent=True):
++parent+=+psutil.Process(pid)
++children+=+parent.children(recursive=True)
++for+child+in+children:
++++child.kill()
++psutil.wait_procs(children,+timeout=5)
++if+including_parent:
++++parent.kill()
++++parent.wait(5)

def+run_with_timeout(cmd,+current_dir,+cmd_parms,+timeout):
++def+target():
++++process+=+subprocess.Popen(cmd,+cwd=current_dir,+shell=True,+stdout=subprocess.PIPE,+stdin=subprocess.PIPE,+stderr=subprocess.PIPE)

++++#+wait+for+the+process+to+terminate
++++if+(cmd_parms+==+""):
++++++out,+err+=+process.communicate()
++++else:
++++++out,+err+=+process.communicate(cmd_parms)
++++errcode+=+process.returncode

++thread+=+Thread(target=target)
++thread.start()

++thread.join(timeout)
++if+thread.is_alive():
++++me+=+os.getpid()
++++kill_proc_tree(me,+including_parent=False)
++++thread.join()|code-block|syntax|javascript|977880|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

This solution kills the process tree in case of shell=True, passes parameters to the process (or not), has a timeout and gets the stdout, stderr and process output of the call back (it uses psutil for the kill_proc_tree). This was based on several solutions posted in SO including jcollado's. Posting in response to comments by Anson and jradice in jcollado's answer. Tested in Windows Srvr 2012 and Ubuntu 14.04. Please note that for Ubuntu you need to change the parent.children(...) call to parent.get_children(...).

<pre><code>def kill_proc_tree(pid, including_parent=True):
 parent = psutil.Process(pid)
 children = parent.children(recursive=True)
 for child in children:
 child.kill()
 psutil.wait_procs(children, timeout=5)
 if including_parent:
 parent.kill()
 parent.wait(5)

def run_with_timeout(cmd, current_dir, cmd_parms, timeout):
 def target():
 process = subprocess.Popen(cmd, cwd=current_dir, shell=True, stdout=subprocess.PIPE, stdin=subprocess.PIPE, stderr=subprocess.PIPE)

 # wait for the process to terminate
 if (cmd_parms == ""):
 out, err = process.communicate()
 else:
 out, err = process.communicate(cmd_parms)
 errcode = process.returncode

 thread = Thread(target=target)
 thread.start()

 thread.join(timeout)
 if thread.is_alive():
 me = os.getpid()
 kill_proc_tree(me, including_parent=False)
 thread.join()
</code></pre>

blocks|key|2418337|text|有一种想法是将Popen类子类化，并使用一些简单的方法装饰器对其进行扩展。我们叫它ExpirablePopen吧。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2418338|from+logging+import+error
from+subprocess+import+Popen
from+threading+import+Event
from+threading+import+Thread


class+ExpirablePopen(Popen):

++++def+__init__(self,+*args,+**kwargs):
++++++++self.timeout+=+kwargs.pop('timeout',+0)
++++++++self.timer+=+None
++++++++self.done+=+Event()

++++++++Popen.__init__(self,+*args,+**kwargs)

++++def+__tkill(self):
++++++++timeout+=+self.timeout
++++++++if+not+self.done.wait(timeout):
++++++++++++error('Terminating+process+{}+by+timeout+of+{}+secs.'.format(self.pid,+timeout))
++++++++++++self.kill()

++++def+expirable(func):
++++++++def+wrapper(self,+*args,+**kwargs):
++++++++++++#+zero+timeout+means+call+of+parent+method
++++++++++++if+self.timeout+==+0:
++++++++++++++++return+func(self,+*args,+**kwargs)

++++++++++++#+if+timer+is+None,+need+to+start+it
++++++++++++if+self.timer+is+None:
++++++++++++++++self.timer+=+thr+=+Thread(target=self.__tkill)
++++++++++++++++thr.daemon+=+True
++++++++++++++++thr.start()

++++++++++++result+=+func(self,+*args,+**kwargs)
++++++++++++self.done.set()

++++++++++++return+result
++++++++return+wrapper

++++wait+=+expirable(Popen.wait)
++++communicate+=+expirable(Popen.communicate)


if+__name__+==+'__main__':
++++from+subprocess+import+PIPE

++++print+ExpirablePopen('ssh+-T+git@bitbucket.org',+stdout=PIPE,+timeout=1).communicate()|code-block|syntax|javascript|2418339|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

There's an idea to subclass the Popen class and extend it with some simple method decorators. Let's call it ExpirablePopen.

<pre><code>from logging import error
from subprocess import Popen
from threading import Event
from threading import Thread


class ExpirablePopen(Popen):

 def __init__(self, *args, **kwargs):
 self.timeout = kwargs.pop('timeout', 0)
 self.timer = None
 self.done = Event()

 Popen.__init__(self, *args, **kwargs)

 def __tkill(self):
 timeout = self.timeout
 if not self.done.wait(timeout):
 error('Terminating process {} by timeout of {} secs.'.format(self.pid, timeout))
 self.kill()

 def expirable(func):
 def wrapper(self, *args, **kwargs):
 # zero timeout means call of parent method
 if self.timeout == 0:
 return func(self, *args, **kwargs)

 # if timer is None, need to start it
 if self.timer is None:
 self.timer = thr = Thread(target=self.__tkill)
 thr.daemon = True
 thr.start()

 result = func(self, *args, **kwargs)
 self.done.set()

 return result
 return wrapper

 wait = expirable(Popen.wait)
 communicate = expirable(Popen.communicate)


if __name__ == '__main__':
 from subprocess import PIPE

 print ExpirablePopen('ssh -T git@bitbucket.org', stdout=PIPE, timeout=1).communicate()
</code></pre>

blocks|key|2418349|text|您可以使用select来完成这个任务。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2418350|import+subprocess
from+datetime+import+datetime
from+select+import+select

def+call_with_timeout(cmd,+timeout):
++++started+=+datetime.now()
++++sp+=+subprocess.Popen(cmd,+stdout=subprocess.PIPE)
++++while+True:
++++++++p+=+select([sp.stdout],+[],+[],+timeout)
++++++++if+p[0]:
++++++++++++p[0][0].read()
++++++++ret+=+sp.poll()
++++++++if+ret+is+not+None:
++++++++++++return+ret
++++++++if+(datetime.now()-started).total_seconds()+>+timeout:
++++++++++++sp.kill()
++++++++++++return+None|code-block|syntax|javascript|2418351|entityMap^0|5|6|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

You can do this using <code>select</code>

<pre><code>import subprocess
from datetime import datetime
from select import select

def call_with_timeout(cmd, timeout):
 started = datetime.now()
 sp = subprocess.Popen(cmd, stdout=subprocess.PIPE)
 while True:
 p = select([sp.stdout], [], [], timeout)
 if p[0]:
 p[0][0].read()
 ret = sp.poll()
 if ret is not None:
 return ret
 if (datetime.now()-started).total_seconds() &gt; timeout:
 sp.kill()
 return None
</code></pre>

blocks|key|2418386|text|我遇到的问题是，如果多线程子进程花费的时间超过给定的超时长度，我希望终止它。我想在Popen()中设置一个超时，但它没有起作用。然后，我意识到Popen().wait()等于call()，所以我想在.wait(timeout=xxx)方法中设置一个超时，这个方法终于起作用了。因此，我以这样的方式解决了这个问题：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2418387|import+os
import+sys
import+signal
import+subprocess
from+multiprocessing+import+Pool

cores_for_parallelization+=+4
timeout_time+=+15++#+seconds

def+main():
++++jobs+=+[...YOUR_JOB_LIST...]
++++with+Pool(cores_for_parallelization)+as+p:
++++++++p.map(run_parallel_jobs,+jobs)

def+run_parallel_jobs(args):
++++#+Define+the+arguments+including+the+paths
++++initial_terminal_command+=+'C:\\Python34\\python.exe'++#+Python+executable
++++function_to_start+=+'C:\\temp\\xyz.py'++#+The+multithreading+script
++++final_list+=+[initial_terminal_command,+function_to_start]
++++final_list.extend(args)

++++#+Start+the+subprocess+and+determine+the+process+PID
++++subp+=+subprocess.Popen(final_list)++#+starts+the+process
++++pid+=+subp.pid

++++#+Wait+until+the+return+code+returns+from+the+function+by+considering+the+timeout.+
++++#+If+not,+terminate+the+process.
++++try:
++++++++returncode+=+subp.wait(timeout=timeout_time)++#+should+be+zero+if+accomplished
++++except+subprocess.TimeoutExpired:
++++++++#+Distinguish+between+Linux+and+Windows+and+terminate+the+process+if+
++++++++#+the+timeout+has+been+expired
++++++++if+sys.platform+==+'linux2':
++++++++++++os.kill(pid,+signal.SIGTERM)
++++++++elif+sys.platform+==+'win32':
++++++++++++subp.terminate()

if+__name__+==+'__main__':
++++main()|code-block|syntax|javascript|2418388|entityMap^0|15|7|1Z|E|2F|6|2R|I|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]|$9|R|A|S|B|C]|$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|L|$]]

I had the problem that I wanted to terminate a multithreading subprocess if it took longer than a given timeout length. I wanted to set a timeout in <code>Popen()</code>, but it did not work. Then, I realized that <code>Popen().wait()</code> is equal to <code>call()</code> and so I had the idea to set a timeout within the <code>.wait(timeout=xxx)</code> method, which finally worked. Thus, I solved it this way:

<pre><code>import os
import sys
import signal
import subprocess
from multiprocessing import Pool

cores_for_parallelization = 4
timeout_time = 15 # seconds

def main():
 jobs = [...YOUR_JOB_LIST...]
 with Pool(cores_for_parallelization) as p:
 p.map(run_parallel_jobs, jobs)

def run_parallel_jobs(args):
 # Define the arguments including the paths
 initial_terminal_command = 'C:\\Python34\\python.exe' # Python executable
 function_to_start = 'C:\\temp\\xyz.py' # The multithreading script
 final_list = [initial_terminal_command, function_to_start]
 final_list.extend(args)

 # Start the subprocess and determine the process PID
 subp = subprocess.Popen(final_list) # starts the process
 pid = subp.pid

 # Wait until the return code returns from the function by considering the timeout. 
 # If not, terminate the process.
 try:
 returncode = subp.wait(timeout=timeout_time) # should be zero if accomplished
 except subprocess.TimeoutExpired:
 # Distinguish between Linux and Windows and terminate the process if 
 # the timeout has been expired
 if sys.platform == 'linux2':
 os.kill(pid, signal.SIGTERM)
 elif sys.platform == 'win32':
 subp.terminate()

if __name__ == '__main__':
 main()
</code></pre>

blocks|key|977288|text|预置Linux命令timeout并不是一个糟糕的解决方法，它对我起了作用。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|977289|cmd+=+"timeout+20+"%2B+cmd
subprocess.Popen(cmd.split(),+stdout=subprocess.PIPE,+stderr=subprocess.PIPE)
(output,+err)+=+p.communicate()|code-block|syntax|javascript|977290|entityMap^0|9|7|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

Prepending the Linux command <code>timeout</code> isn't a bad workaround and it worked for me.

<pre><code>cmd = "timeout 20 "+ cmd
subprocess.Popen(cmd.split(), stdout=subprocess.PIPE, stderr=subprocess.PIPE)
(output, err) = p.communicate()
</code></pre>

blocks|key|977303|text|自从Python3.5之后，就有了一个新的subprocess.run通用命令(用于替换check_call、check_output+.)其中也有timeout=参数。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|CODE|entityRanges|data|977304|subprocess.run(args，*，stdin=None，input=None，stdout=None，stderr=None，shell=False，cwd=None，cwd=None+check=False，encoding=None，errors=None)
运行args描述的命令。等待命令完成，然后返回一个CompletedProcess实例。|blockquote|977305|当超时过期时，它将引发subprocess.TimeoutExpired异常。|977306|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.python.org/3/library/subprocess.html#subprocess.run|1|https://docs.python.org/3/library/subprocess.html#subprocess.CompletedProcess|2|https://docs.python.org/3/library/subprocess.html#subprocess.TimeoutExpired^0|2|9|L|E|18|A|1J|C|22|8|L|E|0|0|B|3|4I|G|4I|G|1|0|B|P|B|P|2|0^^$0|@$1|2|3|4|5|6|7|X|8|@$9|Y|A|Z|B|C]|$9|10|A|11|B|D]|$9|12|A|13|B|D]|$9|14|A|15|B|D]|$9|16|A|17|B|D]]|E|@$9|18|A|19|1|1A]]|F|$]]|$1|G|3|H|5|I|7|1B|8|@$9|1C|A|1D|B|C]|$9|1E|A|1F|B|D]]|E|@$9|1G|A|1H|1|1I]]|F|$]]|$1|J|3|K|5|6|7|1J|8|@$9|1K|A|1L|B|D]]|E|@$9|1M|A|1N|1|1O]]|F|$]]|$1|L|3|-4|5|6|7|1P|8|@]|E|@]|F|$]]]|M|$N|$5|O|P|Q|F|$R|S]]|T|$5|O|P|Q|F|$R|U]]|V|$5|O|P|Q|F|$R|W]]]]

Since Python 3.5, there's a new <a href="https://docs.python.org/3/library/subprocess.html#subprocess.run" rel="noreferrer"><code>subprocess.run</code></a> universal command (that is meant to replace <code>check_call</code>, <code>check_output</code> ...) and which has the <code>timeout=</code> parameter as well.
<blockquote>
subprocess.run(args, *, stdin=None, input=None, stdout=None, stderr=None, shell=False, cwd=None, timeout=None, check=False, encoding=None, errors=None)
Run the command described by args. Wait for command to complete, then return a <a href="https://docs.python.org/3/library/subprocess.html#subprocess.CompletedProcess" rel="noreferrer"><code>CompletedProcess</code></a> instance.
</blockquote>
It raises a <a href="https://docs.python.org/3/library/subprocess.html#subprocess.TimeoutExpired" rel="noreferrer"><code>subprocess.TimeoutExpired</code></a> exception when the timeout expires.

blocks|key|892491|text|对于python+2.6%2B，请使用gevent。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|892492|+from+gevent.subprocess+import+Popen,+PIPE,+STDOUT

+def+call_sys(cmd,+timeout):
++++++p=+Popen(cmd,+shell=True,+stdout=PIPE)
++++++output,+_+=+p.communicate(timeout=timeout)
++++++assert+p.returncode+==+0,+p.+returncode
++++++return+output

+call_sys('./t.sh',+2)

+#+t.sh+example
+sleep+5
+echo+done
+exit+1|code-block|syntax|javascript|892493|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

for python 2.6+, use gevent

<pre><code> from gevent.subprocess import Popen, PIPE, STDOUT

 def call_sys(cmd, timeout):
 p= Popen(cmd, shell=True, stdout=PIPE)
 output, _ = p.communicate(timeout=timeout)
 assert p.returncode == 0, p. returncode
 return output

 call_sys('./t.sh', 2)

 # t.sh example
 sleep 5
 echo done
 exit 1
</code></pre>

blocks|key|892498|text|python+2.7|type|unstyled|depth|inlineStyleRanges|entityRanges|data|892499|import+time
import+subprocess

def+run_command(cmd,+timeout=0):
++++start_time+=+time.time()
++++df+=+subprocess.Popen(cmd,+stdout=subprocess.PIPE,+stderr=subprocess.PIPE)
++++while+timeout+and+df.poll()+==+None:
++++++++if+time.time()-start_time+>=+timeout:
++++++++++++df.kill()
++++++++++++return+-1,+""
++++output+=+'\n'.join(df.communicate()).strip()
++++return+df.returncode,+output|code-block|syntax|javascript|892500|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

python 2.7

<pre><code>import time
import subprocess

def run_command(cmd, timeout=0):
 start_time = time.time()
 df = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
 while timeout and df.poll() == None:
 if time.time()-start_time &gt;= timeout:
 df.kill()
 return -1, ""
 output = '\n'.join(df.communicate()).strip()
 return df.returncode, output
</code></pre>

blocks|key|892545|text|在Python+3.7.8中测试超时后捕获的输出示例：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|892546|try:
++++return+subprocess.run(command,+shell=True,+capture_output=True,+timeout=20,+cwd=cwd,+universal_newlines=True)
except+subprocess.TimeoutExpired+as+e:
++++print(e.output.decode(encoding="utf-8",+errors="ignore"))
++++assert+False;|code-block|syntax|javascript|892547|异常subprocess.TimeoutExpired具有输出和其他成员：|892548|cmd+-用于生成子进程的命令。
超时-超时以秒为单位。
输出-如果运行()或check_output()捕获子进程的输出。否则，什么都不会。
标准输出-输出的别名，用于与stderr对称。
如果由run()捕获子进程的stderr输出。否则，什么都不会。|blockquote|892549|更多信息：https://docs.python.org/3/library/subprocess.html#subprocess.TimeoutExpired|offset|length|892550|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.python.org/3/library/subprocess.html#subprocess.TimeoutExpired^0|0|0|0|0|5|23|0|0^^$0|@$1|2|3|4|5|6|7|X|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|Y|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Z|8|@]|9|@]|A|$]]|$1|I|3|J|5|K|7|10|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|11|8|@]|9|@$N|12|O|13|1|14]]|A|$]]|$1|P|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|Q|$R|$5|S|T|U|A|$V|W]]]]

Example of captured output after timeout tested in Python 3.7.8:
<pre><code>try:
 return subprocess.run(command, shell=True, capture_output=True, timeout=20, cwd=cwd, universal_newlines=True)
except subprocess.TimeoutExpired as e:
 print(e.output.decode(encoding=&quot;utf-8&quot;, errors=&quot;ignore&quot;))
 assert False;
</code></pre>
The exception subprocess.TimeoutExpired has the output and other members:
<blockquote>
cmd - Command that was used to spawn the child process.
timeout - Timeout in seconds.
output - Output of the child process if it was captured by run() or
check_output(). Otherwise, None.
stdout - Alias for output, for symmetry with stderr.
stderr - Stderr output of the child process if it was captured by
run(). Otherwise, None.
</blockquote>
More info: <a href="https://docs.python.org/3/library/subprocess.html#subprocess.TimeoutExpired" rel="nofollow noreferrer">https://docs.python.org/3/library/subprocess.html#subprocess.TimeoutExpired</a>

blocks|key|2418536|text|只对Linux进行迟答，但如果有人想使用subprocess.getstatusoutput()，而超时参数不可用，则可以在命令开头使用内置Linux超时，即：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2418537|import+subprocess

timeout+=+25+#+seconds
cmd+=+f"timeout+--preserve-status+--foreground+{timeout}+ping+duckgo.com"
exit_c,+out+=+subprocess.getstatusoutput(cmd)

if+(exit_c+==+0):
++++print("success")
else:
++++print("Error:+",+out)|code-block|syntax|javascript|2418538|timeout参数：|2418539|--preserve-status：保持退出状态|unordered-list-item|2418540|--foreground：在前景运行|2418541|25：以秒为单位的超时值|2418542|entityMap|0|LINK|mutability|MUTABLE|url|https://linuxize.com/post/timeout-command-in-linux/|1|https://linuxize.com/post/timeout-command-in-linux/#preserving-the-exit-status|2|https://linuxize.com/post/timeout-command-in-linux/#running-in-foreground^0|2|5|K|S|1W|9|0|0|0|0|7|0|0|H|I|6|1|0|0|C|D|5|2|0|0|2|0^^$0|@$1|2|3|4|5|6|7|15|8|@$9|16|A|17|B|C]|$9|18|A|19|B|C]]|D|@$9|1A|A|1B|1|1C]]|E|$]]|$1|F|3|G|5|H|7|1D|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|1E|8|@$9|1F|A|1G|B|C]]|D|@]|E|$]]|$1|M|3|N|5|O|7|1H|8|@$9|1I|A|1J|B|C]]|D|@$9|1K|A|1L|1|1M]]|E|$]]|$1|P|3|Q|5|O|7|1N|8|@$9|1O|A|1P|B|C]]|D|@$9|1Q|A|1R|1|1S]]|E|$]]|$1|R|3|S|5|O|7|1T|8|@$9|1U|A|1V|B|C]]|D|@]|E|$]]|$1|T|3|-4|5|6|7|1W|8|@]|D|@]|E|$]]]|U|$V|$5|W|X|Y|E|$Z|10]]|11|$5|W|X|Y|E|$Z|12]]|13|$5|W|X|Y|E|$Z|14]]]]

Late answer for <code>Linux</code> only, but in case someone wants to use <code>subprocess.getstatusoutput()</code>, where the timeout argument isn't available, you can use the <a href="https://linuxize.com/post/timeout-command-in-linux/" rel="nofollow noreferrer">built-in Linux timeout</a> on the beginning of the command, i.e.:
<pre><code>import subprocess

timeout = 25 # seconds
cmd = f&quot;timeout --preserve-status --foreground {timeout} ping duckgo.com&quot;
exit_c, out = subprocess.getstatusoutput(cmd)

if (exit_c == 0):
 print(&quot;success&quot;)
else:
 print(&quot;Error: &quot;, out)
</code></pre>
<hr />
<code>timeout</code> Arguments:
<ul>
<li><code>--preserve-status</code> : <a href="https://linuxize.com/post/timeout-command-in-linux/#preserving-the-exit-status" rel="nofollow noreferrer">Preserving the Exit Status</a></li>
<li><code>--foreground</code> : <a href="https://linuxize.com/post/timeout-command-in-linux/#running-in-foreground" rel="nofollow noreferrer">Running in Foreground</a></li>
<li><code>25</code> : timeout value in seconds</li>
</ul>

blocks|key|2418565|text|有时，您需要处理(ffmpeg)而不使用communicate()，在这种情况下，您需要异步超时，这是使用ttldict实现此操作的一种实用方法。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2418566|pip安装ttldict|blockquote|2418567|from+ttldict+import++TTLOrderedDict+++
sp_timeout+=+TTLOrderedDict(default_ttl=10)

def+kill_on_timeout(done,+proc):
++++while+True:
++++++++now+=+time.time()
++++++++if+sp_timeout.get('exp_time')+==+None:
++++++++++++++++proc.kill()
++++++++++++++++break
++++
process+=+subprocess.Popen(cmd,+stdout=subprocess.PIPE,+text=True,+stderr=subprocess.STDOUT)
++++++++++++
sp_timeout['exp_time']+=+time.time()
++++++++++++
done+=+Event()
watcher+=+Thread(target=kill_on_timeout,+args=(done,+process))
watcher.daemon+=+True
watcher.start()
done.set()

for+line+in+process.stdout:
.......|code-block|syntax|javascript|2418568|entityMap^0|K|D|1H|7|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@$9|Q|A|R|B|C]|$9|S|A|T|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|U|8|@]|D|@]|E|$]]|$1|I|3|J|5|K|7|V|8|@]|D|@]|E|$L|M]]|$1|N|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|O|$]]

Sometimes you need to process (ffmpeg) without using <code>communicate()</code> and in this case you need asynchronous timeout, a practical way to do this using <code>ttldict</code>
<blockquote>
pip install ttldict
</blockquote>
<pre><code>from ttldict import TTLOrderedDict 
sp_timeout = TTLOrderedDict(default_ttl=10)

def kill_on_timeout(done, proc):
 while True:
 now = time.time()
 if sp_timeout.get('exp_time') == None:
 proc.kill()
 break
 
process = subprocess.Popen(cmd, stdout=subprocess.PIPE, text=True, stderr=subprocess.STDOUT)
 
sp_timeout['exp_time'] = time.time()
 
done = Event()
watcher = Thread(target=kill_on_timeout, args=(done, process))
watcher.daemon = True
watcher.start()
done.set()

for line in process.stdout:
.......
</code></pre>

Here's the Python code to run an arbitrary command returning its <code>stdout</code> data, or raise an exception on non-zero exit codes:

<pre><code>proc = subprocess.Popen(
 cmd,
 stderr=subprocess.STDOUT, # Merge stdout and stderr
 stdout=subprocess.PIPE,
 shell=True)
</code></pre>

<code>communicate</code> is used to wait for the process to exit:

<pre><code>stdoutdata, stderrdata = proc.communicate()
</code></pre>

The <code>subprocess</code> module does not support timeout--ability to kill a process running for more than X number of seconds--therefore, <code>communicate</code> may take forever to run.

What is the simplest way to implement timeouts in a Python program meant to run on Windows and Linux?

Using module 'subprocess' with timeout

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

下面是运行返回其stdout数据的任意命令的Python代码，或者对非零退出代码引发异常：proc = subprocess.Popen(    cmd,    stderr=subprocess.STDOUT,  # Merge stdout and stderr    stdout=subprocess.PIPE,...

问在超时的情况下使用模块“子进程”
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在超时的情况下使用模块“子进程”EN