Come limitare il tempo di esecuzione del programma quando si utilizza il sottoprocesso?

Question

Desidero utilizzare il sottoprocesso per eseguire un programma, ma è necessario limitare il tempo di esecuzione. Ad esempio, se viene eseguito più di 2 secondi, voglio ucciderlo.

Per i programmi comuni, kill() funziona correttamente. Ma se provo a eseguire /usr/bin/time something, kill() non può davvero uccidere il programma.

Ma il mio codice di seguito sembra non funzionare bene, il programma è ancora in esecuzione.

import subprocess 
import time 

exec_proc = subprocess.Popen("/usr/bin/time -f \"%e\\n%M\" ./son > /dev/null", stdout = subprocess.PIPE, stderr = subprocess.STDOUT, shell = True) 

max_time = 1 
cur_time = 0.0 
return_code = 0 
while cur_time <= max_time: 
    if exec_proc.poll() != None: 
     return_code = exec_proc.poll() 
     break 
    time.sleep(0.1) 
    cur_time += 0.1 

if cur_time > max_time: 
    exec_proc.kill() 

Answer 1

farlo in questo modo nella riga di comando:

perl -e 'alarm shift @ARGV; exec @ARGV' <timeout> <your_command> 

questo verrà eseguito il comando <your_command> e terminare in <timeout> secondo.

un esempio fittizio:

# set time out to 5, so that the command will be killed after 5 second 
command = ['perl', '-e', "'alarm shift @ARGV; exec @ARGV'", "5"] 

command += ["ping", "www.google.com"] 

exec_proc = subprocess.Popen(command) 

oppure è possibile utilizzare il signal.alarm() se lo vuoi con Python, ma è lo stesso.

Answer 2

Se si utilizza Python 2.6 o versione successiva, è possibile utilizzare il modulo multiprocessing.

from multiprocessing import Process 

def f(): 
    # Stuff to run your process here 

p = Process(target=f) 
p.start() 
p.join(timeout) 
if p.is_alive(): 
    p.terminate() 

---

In realtà, multiprocessing è il modulo sbagliato per questo compito in quanto è solo un modo per controllare quanto a lungo un filo corre. Non hai alcun controllo su eventuali bambini che il thread potrebbe eseguire. Come suggerisce la singolarità, usare signal.alarm è l'approccio normale.

import signal 
import subprocess 

def handle_alarm(signum, frame): 
    # If the alarm is triggered, we're still in the exec_proc.communicate() 
    # call, so use exec_proc.kill() to end the process. 
    frame.f_locals['self'].kill() 

max_time = ... 
stdout = stderr = None 
signal.signal(signal.SIGALRM, handle_alarm) 
exec_proc = subprocess.Popen(['time', 'ping', '-c', '5', 'google.com'], 
          stdin=None, stdout=subprocess.PIPE, 
          stderr=subprocess.STDOUT) 
signal.alarm(max_time) 
try: 
    (stdout, stderr) = exec_proc.communicate() 
except IOError: 
    # process was killed due to exceeding the alarm 
finally: 
    signal.alarm(0) 
# do stuff with stdout/stderr if they're not None 

Answer 3

Io uso os.kill(), ma non sono sicuro se funziona su tutti i sistemi operativi.
Segue lo pseudo codice e vedi la pagina Doug Hellman.

proc = subprocess.Popen(['google-chrome'])            
os.kill(proc.pid, signal.SIGUSR1)</code>