¿Por qué es necesario volver a crear la instancia al reiniciar un hilo?

Imagina las siguientes clases:

Class Object(threading.Thread): # some initialisation blabla def run(self): while True: # do something sleep(1) class Checker(): def check_if_thread_is_alive(self): o = Object() o.start() while True: if not o.is_alive(): o.start() 

Quiero reiniciar el hilo en caso de que esté muerto. Esto no funciona. Porque los hilos solo se pueden iniciar una vez. Primera pregunta. ¿Por qué es esto?

Por lo que sé, tengo que volver a crear cada instancia de Object y llamar a start() para volver a iniciar el hilo. En caso de Object complejos esto no es muy práctico. Tengo que leer los valores actuales del Object antiguo, crear uno nuevo y establecer los parámetros en el nuevo objeto con los valores antiguos. Segunda pregunta: ¿Se puede hacer esto de una manera más inteligente y fácil?

La razón por la que se implementa el subproceso. El subproceso se implementa de esa manera es para mantener la correspondencia entre un objeto de subproceso y el subproceso del sistema operativo. En los principales sistemas operativos, los subprocesos no se pueden reiniciar, pero puede crear otro subproceso con otro ID de subproceso .

Si la recreación es un problema, no hay necesidad de heredar su clase de subprocesos. Hilo, simplemente pase un parámetro de destino al constructor de Hilos como este:

 class MyObj(object): def __init__(self): self.thread = threading.Thread(target=self.run) def run(self): ... 

Luego, puede acceder al miembro del hilo para controlar la ejecución de su hilo y volver a crearlo según sea necesario. No se requiere recreación MyObj.

Consulte aquí: http://docs.python.org/2/library/threading.html#threading.Thread.start

Debe ser llamado a lo más una vez por objeto de hilo. Organiza la invocación del método run () del objeto en un hilo de control separado.

Este método generará un RuntimeError si se llama más de una vez en el mismo objeto de hilo.

Un hilo no está destinado a ejecutarse más de una vez. Es posible que desee utilizar un grupo de subprocesos

Creo que eso tiene que ver con cómo se implementa la clase Thread . Envuelve un subproceso real del sistema operativo, de modo que al reiniciar el subproceso realmente cambiaría su identidad, lo que podría ser confuso.

Una mejor manera de lidiar con los hilos es en realidad a través de funciones / llamadas de destino:

 class Worker(object): """ Implements the logic to be run in separate threads """ def __call__(self): # do useful stuff and change the state class Supervisor(): def run(self, worker): thr = None while True: if not thr or not thr.is_alive(): thr = Thread(target=worker) thr.daemon = True thr.start() thr.join(1) # give it some time