Come interrompere un thread java con garbo?

Question

Ho scritto una discussione, ci vuole troppo tempo per l'esecuzione e sembra che non sia stata completata. Voglio fermare il filo con grazia. Qualsiasi aiuto ?

Answer 1

Il buon modo per farlo è quello di avere la run() del Filo custodito da una variabile boolean e impostarlo true dall'esterno quando si vuole fermare, qualcosa come:

class MyThread extends Thread 
{ 
    volatile boolean finished = false; 

    public void stopMe() 
    { 
    finished = true; 
    } 

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

C'era una volta un metodo stop() ma come afferma la documentazione

Questo metodo è intrinsecamente pericoloso. L'interruzione di una discussione con Thread.stop lo fa sbloccare tutti i monitor che ha bloccato (come conseguenza naturale dell'eccezione ThreadDeath non verificata che si propaga nello stack). Se uno qualsiasi degli oggetti precedentemente protetti da questi monitor si trovavano in uno stato incoerente, gli oggetti danneggiati diventano visibili ad altri thread, determinando potenzialmente un comportamento arbitrario.

Ecco perché si dovrebbe avere una guardia ..

Answer 2

Creare una variabile booleana stop da qualche parte. Poi nel codice che viene eseguito nel thread, regolarmente fare

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

Per fermare il filo, impostare stop a true.

Penso che devi farlo manualmente in questo modo. Dopotutto, solo il codice in esecuzione nel thread ha qualche idea di cosa sia e non sia grazioso.

Answer 3

Non si dovrebbe uccidere filo da altro. È considerato un'abitudine abbastanza brutta. Tuttavia, ci sono molti modi. È possibile utilizzare l'istruzione return dal metodo run del thread. Oppure puoi verificare se il thread è già stato interrotto e poi annullerà il suo lavoro. F.e. :

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

Answer 4

È necessario inviare uno stop-messaggio al filo e il filo stesso deve agire se è stato ricevuto il messaggio. Questo è abbastanza facile, se l'azione di lunga durata è all'interno del ciclo:

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

La parte negativa sull'utilizzo di una bandiera per evitare che il filo è che se il thread è in attesa o dormire poi si deve aspettare che si Finisci di aspettare/dormire. Se si chiama il metodo di interrupt sul thread, questo causerà l'interruzione della chiamata di attesa o sospensione con un InterruptedException.

La chiamata interrupt() imposta anche una proprietà interrotta che è possibile utilizzare come flag per controllare se chiudere (nel caso in cui il thread non sia in attesa o inattivo).

È possibile scrivere il metodo di esecuzione del thread in modo che InterruptedException venga catturato al di fuori di qualsiasi logica di loop del thread, oppure è possibile rilevare l'eccezione all'interno del loop e chiudere la chiamata che genera l'eccezione, impostando il flag di interrupt all'interno del catch block per InterruptedException in modo che il thread non perda traccia del fatto che è stato interrotto. Il thread interrotto può ancora mantenere il controllo e terminare l'elaborazione alle sue condizioni.

Dire che voglio scrivere un thread di lavoro che funzioni in incrementi, dove c'è un sonno nel mezzo per qualche motivo, e non voglio uscire dal sonno per far sì che l'elaborazione si interrompa senza fare il lavoro rimanente per quell'incremento , voglio solo che per uscire se è in-tra incrementi:

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

per un filo di fermarsi, nessuno sembra aver menzionato (mis) con un'eccezione:

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 sottoclasse deve solo eseguire override doRun() normalmente come si farebbe con una discussione e chiamare stopSelf() ogni volta che si desidera arrestarla. IMO sembra più pulito che usare un flag in un ciclo while.