¿Cómo detener un hilo de Java con gracia?

Question

Escribí un hilo, está tardando demasiado tiempo en ejecutarse y parece que no está completamente terminado. Quiero detener el hilo con gracia. Alguna ayuda ?

Answer 1

El buena manera de hacerlo es tener la run() de la rosca vigilado por una variable boolean y ponerlo a true desde el exterior cuando se desea detenerlo, algo así como:

class MyThread extends Thread 
{ 
    volatile boolean finished = false; 

    public void stopMe() 
    { 
    finished = true; 
    } 

    public void run() 
    { 
    while (!finished) 
    { 
     //do dirty work 
    } 
    } 
} 

Érase una vez un método stop() existía pero como la documentación indica

Este método es inherentemente inseguro. Detener un hilo con Thread.stop hace que desbloquee todos los monitores que ha bloqueado (como consecuencia natural de la excepción ThreadDeath no verificada que se propaga por la pila). Si alguno de los objetos previamente protegidos por estos monitores se encontraba en un estado incoherente, los objetos dañados se vuelven visibles para otros hilos, lo que puede generar un comportamiento arbitrario.

Es por eso que usted debe tener un guardia ..

Answer 2

Haz un booleano volátil stop en alguna parte. Luego, en el código que se ejecuta en el hilo, hacer regularmente

if (stop) // end gracefully by breaking out of loop or whatever 

Para detener el hilo, fijado a stoptrue.

Creo que debe hacerlo manualmente de esta manera. Después de todo, solo el código que se ejecuta en el hilo tiene alguna idea de lo que es y no es gracioso.

Answer 3

Usted no debe matar a rosca de otro. Se considera un hábito bastante malo. Sin embargo, hay muchas formas. Puede usar la instrucción return desde el método run del hilo. O puede verificar si el hilo ya ha sido interrumpido y luego cancelará su trabajo. F.e. :

while (!isInterrupted()) { 
    // doStuff 
} 

Answer 4

Es necesario enviar un mensaje de detención al hilo y el hilo en sí tiene que tomar medidas si el mensaje ha sido recibido. Esto es bastante fácil, si la acción de larga duración está dentro del bucle:

public class StoppableThread extends Thread { 

    private volatile boolean stop = false; 

    public void stopGracefully() { 
    stop = true; 
    } 

    public void run() { 
    boolean finished = false; 
    while (!stop && !finished) { 
     // long running action - finished will be true once work is done 
    } 
    } 
} 

Answer 5

Lo malo de usar una bandera para detener el hilo es que si el hilo está esperando o dormir entonces usted tiene que esperar a que se terminar esperando/durmiendo. Si llama al método de interrupción en el subproceso, eso hará que la llamada de espera o de espera se cierre con una excepción interrumpida.

La interrupción de llamada() también establece una propiedad interrumpida que puede usar como indicador para comprobar si se cierra (en caso de que el hilo no esté esperando o durmiendo).

Puede escribir método run del hilo para que la InterruptedException es atrapado fuera de cualquier bucle lógica de la rosca está haciendo, o se puede detectar la excepción dentro del bucle y cerca de la llamada lanzar la excepción, estableciendo el indicador de interrupción dentro de la catch block para InterruptedException para que el hilo no pierda de vista el hecho de que fue interrumpido. El hilo interrumpido aún puede mantener el control y finalizar el procesamiento en sus propios términos.

Digamos que quiero escribir un subproceso de trabajo que funciona en incrementos, donde hay una pausa en el medio por alguna razón, y no quiero dejar el reposo para que el proceso se cierre sin hacer el trabajo restante para ese incremento , sólo lo quieren dejar de fumar si está en el medio incrementos:

class MyThread extends Thread 
{ 
    public void run() 
    { 
     while (!Thread.currentThread().isInterrupted()) 
     { 
      doFirstPartOfIncrement(); 
      try { 
       Thread.sleep(10000L); 
      } catch (InterruptedException e) { 
       // restore interrupt flag 
       Thread.currentThread().interrupt(); 
      } 
      doSecondPartOfIncrement(); 
     } 
    } 
} 

Here is an answer to a similar question, including example code.

Answer 6

para un hilo para detener la misma, nadie parece haber mencionado (mal) uso de excepción:

abstract class SelfStoppingThread extends Thread { 

    @Override 
    public final void run() { 
     try { 
      doRun(); 
     } catch (final Stop stop) { 
      //optional logging 
     } 
    } 

    abstract void doRun(); 

    protected final void stopSelf() { 
     throw new Stop(); 
    } 

    private static final class Stop extends RuntimeException {}; 

} 

Una subclase sólo tiene que anular doRun() normalmente como lo haría con un hilo, y llamar a stopSelf() cada vez que se siente como que quiere parar. OMI se siente más limpio que usar una bandera en un ciclo while.