¿Matar o terminar el subproceso cuando se agota el tiempo de espera?

Question

Me gustaría ejecutar repetidamente un subproceso lo más rápido posible. Sin embargo, a veces el proceso llevará demasiado tiempo, así que quiero matarlo. utilizo signal.signal (...), como a continuación:

ppid=pipeexe.pid 
signal.signal(signal.SIGALRM, stop_handler) 

signal.alarm(1) 
..... 
def stop_handler(signal, frame): 
    print 'Stop test'+testdir+'for time out' 
    if(pipeexe.poll()==None and hasattr(signal, "SIGKILL")): 
     os.kill(ppid, signal.SIGKILL) 
     return False 

pero en algún momento este código a tratar de detener la siguiente ronda de la ejecución. Prueba de detención/home/lu/workspace/152/treefit/test2 para tiempo de espera /bin/sh:/home/lu/workspace/153/squib_driver: no encontrado --- esta es la siguiente ejecución; el programa lo detiene incorrectamente.

¿Alguien sabe cómo solucionar esto? Quiero detenerme a tiempo para no ejecutar 1 segundo el tiempo. Sueño (n) a menudo espera n segundos. No quiero que lo quiera. Puede ejecutar menos de 1 segundo

Answer 1

se podría hacer algo como esto:

import subprocess as sub 
import threading 

class RunCmd(threading.Thread): 
    def __init__(self, cmd, timeout): 
     threading.Thread.__init__(self) 
     self.cmd = cmd 
     self.timeout = timeout 

    def run(self): 
     self.p = sub.Popen(self.cmd) 
     self.p.wait() 

    def Run(self): 
     self.start() 
     self.join(self.timeout) 

     if self.is_alive(): 
      self.p.terminate()  #use self.p.kill() if process needs a kill -9 
      self.join() 

RunCmd(["./someProg", "arg1"], 60).Run() 

La idea es que se crea un hilo que corre el comando y para acabar con él si el tiempo de espera supera un cierto valor adecuado, en este caso 60 segundos.

Answer 2

Supongo que este es un problema de sincronización común en la programación orientada a eventos con subprocesos y procesos.

Si siempre debe tener un solo subproceso ejecutándose, asegúrese de que el subproceso actual se elimine antes de ejecutar el siguiente. De lo contrario, el manejador de señal puede obtener una referencia al último subproceso ejecutado e ignorar el anterior.

Supongamos que se está ejecutando el subproceso A. Antes de manejar la señal de alarma, se inicia el subproceso B. Justo después de eso, su manejador de señal de alarma intenta matar un subproceso. Como el PID actual (o el objeto de la tubería del subproceso actual) se configuró en B al iniciar el subproceso, B muere y A se sigue ejecutando.

¿Mi conjetura es correcta?

Para hacer que su código sea más fácil de entender, incluiría la parte que crea un nuevo subproceso justo después de la parte que elimina el subproceso actual. Eso dejaría en claro que solo hay un subproceso ejecutándose en cualquier momento. El manejador de señal podría hacer tanto el subproceso matando y lanzando, como si fuera el bloque de iteración que se ejecuta en un bucle, en este caso controlado por eventos con la señal de alarma cada 1 segundo.

Answer 3

Aquí hay algo que escribí como un perro guardián para la ejecución del subproceso. Yo uso ahora mucho, pero no estoy tan experimentado así que tal vez hay algunos defectos en él:

import subprocess 
import time 

def subprocess_execute(command, time_out=60): 
    """executing the command with a watchdog""" 

    # launching the command 
    c = subprocess.Popen(command) 

    # now waiting for the command to complete 
    t = 0 
    while t < time_out and c.poll() is None: 
     time.sleep(1) # (comment 1) 
     t += 1 

    # there are two possibilities for the while to have stopped: 
    if c.poll() is None: 
     # in the case the process did not complete, we kill it 
     c.terminate() 
     # and fill the return code with some error value 
     returncode = -1 # (comment 2) 

    else:     
     # in the case the process completed normally 
     returncode = c.poll() 

    return returncode 

de uso:

return = subprocess_execute(['java', '-jar', 'some.jar']) 

Comentarios:

1. aquí, el el tiempo de espera del perro guardián es en segundos; pero es fácil cambiar a lo que sea necesario cambiando el valor time.sleep(). El time_out deberá documentarse en consecuencia;
2. según lo que se necesite, aquí quizás sea más adecuado plantear algunas excepciones.

Documentación: Me ha costado un poco con la documentación del módulo de subprocess entender que subprocess.Popen no bloquea; el proceso se ejecuta en paralelo (tal vez no use la palabra correcta aquí, pero creo que es comprensible).

Pero como lo que escribí es lineal en su ejecución, realmente tengo que esperar a que termine el comando, con un tiempo de espera para evitar errores en el comando para pausar la ejecución nocturna del script.

Answer 4

Esto es lo que yo uso:

class KillerThread(threading.Thread): 
    def __init__(self, pid, timeout, event): 
    threading.Thread.__init__(self) 
    self.pid = pid 
    self.timeout = timeout 
    self.event = event 
    self.setDaemon(True) 
    def run(self): 
    self.event.wait(self.timeout) 
    if not self.event.isSet() : 
     try: 
     os.kill(self.pid, signal.SIGKILL) 
     except OSError, e: 
     #This is raised if the process has already completed 
     pass  

def runTimed(dt, dir, args, kwargs): 
    event = threading.Event() 
    cwd = os.getcwd() 
    os.chdir(dir) 
    proc = subprocess.Popen(args, **kwargs) 
    os.chdir(cwd) 
    killer = KillerThread(proc.pid, dt, event) 
    killer.start() 

    (stdout, stderr) = proc.communicate() 
    event.set()  

    return (stdout,stderr, proc.returncode) 

Answer 5

un poco más complejo, que añade un answer to solve a similar problem: Captura de la salida estándar, la alimentación de la entrada estándar, y ser capaz de terminar después de algún tiempo de inactividad y/o después de algún tiempo de ejecución global.