Terminar un programa python multihilo

Question

¿Cómo hacer una respuesta de programa python multihilo al evento de tecla Ctrl + C?

Editar: El código es así:

import threading 
current = 0 

class MyThread(threading.Thread): 
    def __init__(self, total): 
     threading.Thread.__init__(self) 
     self.total = total 

    def stop(self): 
     self._Thread__stop() 

    def run(self): 
     global current 
     while current<self.total: 
      lock = threading.Lock() 
      lock.acquire() 
      current+=1 
      lock.release() 
      print current 

if __name__=='__main__': 

    threads = [] 
    thread_count = 10 
    total = 10000 
    for i in range(0, thread_count): 
     t = MyThread(total) 
     t.setDaemon(True) 
     threads.append(t) 
    for i in range(0, thread_count): 
     threads[i].start() 

traté de eliminar join() en todas las roscas pero todavía no funciona. ¿Es porque el segmento de bloqueo dentro del procedimiento run() de cada hilo?

Editar: El código anterior se supone que funciona, pero siempre interrumpe cuando la variable corriente estaba en 5.000-6.000 gama ya lo largo de los errores de la siguiente manera

Exception in thread Thread-4 (most likely raised during interpreter shutdown): 
Traceback (most recent call last): 
    File "/usr/lib/python2.5/threading.py", line 486, in __bootstrap_inner 
    File "test.py", line 20, in run 
<type 'exceptions.TypeError'>: unsupported operand type(s) for +=: 'NoneType' and 'int' 
Exception in thread Thread-2 (most likely raised during interpreter shutdown): 
Traceback (most recent call last): 
    File "/usr/lib/python2.5/threading.py", line 486, in __bootstrap_inner 
    File "test.py", line 22, in run 

Answer 1

hacer que cada hilo, excepto la principal una daemon (t.daemon = True en 2.6 o mejor, t.setDaemon(True) en 2.6 o menos, para cada objeto de hilo t antes de iniciarlo). De esta forma, cuando el hilo principal recibe KeyboardInterrupt, si no lo detecta o lo atrapa pero decide terminar de todos modos, todo el proceso terminará. Ver the docs.

edición: habiendo acaba de ver el código de la OP (no publicado originalmente) y la afirmación de que "no funciona", parece que tengo que añadir ...:

Por supuesto, si usted quiere que su hilo principal permanezca sensible (p. ej., control-C), no lo obstruya en llamadas de bloqueo, como join en otro hilo, especialmente no totalmente inutilizando bloqueando llamadas, como join ing daemon hilos. Por ejemplo, sólo cambia el último bucle en el hilo principal de la corriente (utterless y perjudicial):

for i in range(0, thread_count): 
    threads[i].join() 

a algo más sensato como:

while threading.active_count() > 0: 
    time.sleep(0.1) 

si su principal no tiene nada mejor que hacer que bien para que todos los hilos terminen por sí mismos o para que se reciba un C de control (u otra señal).

Por supuesto, hay muchos otros patrones que pueden utilizarse si usted prefiere tener sus hilos no terminan bruscamente (como hilos pueden daemonic) - a menos que , también, están sumidos siempre en forma incondicional de bloqueo de llamadas, bloqueo de puertas, y similares;-).

Answer 2

Existen dos formas principales, una limpia y otra sencilla.

La manera limpia es detectar KeyboardInterrupt en su hilo principal y establecer un indicador que los hilos de su fondo puedan verificar para que sepan que salen; aquí está una versión simple/ligeramente desordenado utilizando un mundial:

exitapp = False 
if __name__ == '__main__': 
    try: 
     main() 
    except KeyboardInterrupt: 
     exitapp = True 
     raise 

def threadCode(...): 
    while not exitapp: 
     # do work here, watch for exitapp to be True 

La forma desordenada, pero fácil es coger KeyboardInterrupt y llame os._exit(), que termina todas las discusiones inmediatamente.

Answer 3

Un Trabajador podría ser útil para usted:

#!/usr/bin/env python 

import sys, time 
from threading import * 
from collections import deque 

class Worker(object): 
    def __init__(self, concurrent=1): 
     self.concurrent = concurrent 
     self.queue = deque([]) 
     self.threads = [] 
     self.keep_interrupt = False 

    def _retain_threads(self): 
     while len(self.threads) < self.concurrent: 
      t = Thread(target=self._run, args=[self]) 
      t.setDaemon(True) 
      t.start() 
      self.threads.append(t) 


    def _run(self, *args): 
     while self.queue and not self.keep_interrupt: 
      func, args, kargs = self.queue.popleft() 
      func(*args, **kargs) 

    def add_task(self, func, *args, **kargs): 
     self.queue.append((func, args, kargs)) 

    def start(self, block=False): 
     self._retain_threads() 

     if block: 
      try: 
       while self.threads: 
        self.threads = [t.join(1) or t for t in self.threads if t.isAlive()] 
        if self.queue: 
         self._retain_threads() 
      except KeyboardInterrupt: 
       self.keep_interrupt = True 
       print "alive threads: %d; outstanding tasks: %d" % (len(self.threads), len(self.queue)) 
       print "terminating..." 


# example 
print "starting..." 
worker = Worker(concurrent=50) 

def do_work(): 
    print "item %d done." % len(items) 
    time.sleep(3) 

def main(): 
    for i in xrange(1000): 
     worker.add_task(do_work) 
    worker.start(True) 

main() 
print "done." 

# to keep shell alive 
sys.stdin.readlines() 

Answer 4

preferiría ir con el código propuesto en this blog post:

def main(args): 

    threads = [] 
    for i in range(10): 
     t = Worker() 
     threads.append(t) 
     t.start() 

    while len(threads) > 0: 
     try: 
      # Join all threads using a timeout so it doesn't block 
      # Filter out threads which have been joined or are None 
      threads = [t.join(1000) for t in threads if t is not None and t.isAlive()] 
     except KeyboardInterrupt: 
      print "Ctrl-c received! Sending kill to threads..." 
      for t in threads: 
       t.kill_received = True 

Lo que he cambiado es el t. unirse de t.join (1) a t.join (1000). El número real de segundos no importa, a menos que especifique un número de tiempo de espera, el hilo principal seguirá siendo sensible a Ctrl + C. El excepto en KeyboardInterrupt hace que el manejo de la señal sea más explícito.

Answer 5

Si genera un hilo como tal - myThread = Thread(target = function) - y luego myThread.start(); myThread.join(). Cuando se inicia CTRL-C, el hilo principal no se cierra porque está esperando esa llamada de bloqueo myThread.join(). Para solucionar esto, simplemente ponga un tiempo de espera en la llamada .join(). El tiempo de espera puede ser el tiempo que desee. Si desea que espere indefinidamente, simplemente espere mucho tiempo, como 99999. También es una buena práctica hacer myThread.daemon = True para que todos los subprocesos salgan cuando el hilo principal (no demonio) finalice.

Answer 6

Siempre se puede establecer sus hilos para "daemon" hilos como:

t.daemon = True 
t.start() 

Y cada vez que el hilo principal muere todas las discusiones van a morir con él.

http://www.regexprn.com/2010/05/killing-multithreaded-python-programs.html

Answer 7

thread1 = threading.Thread(target=your_procedure, args = (arg_1, arg_2))  
try: 
     thread1.setDaemon(True) # very important 
     thread1.start() 
except (KeyboardInterrupt, SystemExit): 
     cleanup_stop_thread(); 
     sys.exit() 

Cuando se quiere matar el hilo sólo tiene que utilizar:

thread1.join(0)