Interrompe/uccide un thread corrente

Question

In caso di un timeout specifico, ho bisogno di uccidere/annullare/interrompere/fallire un thread in esecuzione. Io uso ExecutorService per gestire un pool di thread, attraverso il quale sono in grado di annullare l'attività utilizzando il metodo cancel() di Future che rimuove questo dalla vista ExecutorService, ma il thread stesso continua a funzionare.

Guardandosi intorno online, le persone talk about interrupting threads hanno un ciclo che utilizza il metodo isInterrupted() o sono in attesa su IO che può essere gestito dall'affiorare InterruptedException.

Qual è la pratica generale sull'uccisione dei thread che non esegue il ciclo (o ha altri hook) e non sta aspettando l'I/O? Guardandosi intorno, Thread.stop() sembra fare ciò di cui ho bisogno (uccidendo ciecamente il thread) ma non è consigliabile utilizzarlo.

Answer 1

Se si utilizza uno ExecutorService, non si dovrebbe fare un pasticcio con i suoi thread: questa nozione è nascosta dietro l'executor che è una nozione di livello superiore rispetto ai thread e quindi non fornisce metodi per gestirli. Ti consiglio vivamente di fermare l'intero esecutore e non provare a fermare uno dei suoi thread.

Si prega di notare che i thread in un ExecutorService sono in loop, il loro ciclo include l'attesa di un task disponibile nella loro coda di attività.

Non v'è alcun mezzo semplice in Java per fermare un filo che non è un loop, che cosa si può fare è:

• Avere un flag booleano volatile che del thread Runnable assegni da tempo per vedere se deve fermarsi (lo stesso flag che potrebbe essere usato come condizione in un loop di thread).
• chiamata Thread.interrupt() da provare (best effort, piuttosto pericoloso se non si sa cosa si sta facendo) interrompe una sincronizzazione legati attesa/blocco/Aquire/... il filo è bloccato in.

Answer 2

I ti consiglierei personalmente di seguire la rotta di interruzione perché è il modo più pulito e il modo elegante per terminare quel thread.

Consente di definire correttamente il nostro obiettivo. Un thread non è altro che un processo separato che sta per eseguire una serie di attività che gli si assegna. Probabilmente dovrai trovare i punti interrompibili nel tuo codice e fare un controllo interrotto() in questi punti. Ovviamente questi punti avrebbero dovuto raggiungere un finale logico.

Per esempio,

public void run(){ 
     if (Thread.currentThread().interrupted()) { 
      return; 
     } 
     //LogicA start 
     //LogicA end 
     if (Thread.currentThread().interrupted()) { 
      return; 
     } 
     //LogicB start 
     //LogicB end 
     if (Thread.currentThread().interrupted()) { 
      return; 
     } 
     //LogicLong start 
     //Long code here cannot end or exit or kill the thread now. Let it finish 
     //LogicLong ends 
     if (Thread.currentThread().interrupted()) { 
      return; 
     } 
     //LogicD start 
     //LogicD end 
} 

Answer 3

Se alread hanno un Executorservice allora si hanno ricevuto un Future già. L'unico modo sano e pulito per annullare il lavoro è quindi chiamare future.cancel(boolean mayInterruptIfRunning). L'impostazione mayInterruptIfRunning interromperà i lavori se è attualmente in esecuzione e non fa nulla se il lavoro non è in esecuzione. Quindi devi solo scrivere il lavoro in un modo per onorare l'interruzione controllando di tanto in tanto Thread.interrupted().

Si prega di notare la differenza tra un lavoro e un thread. Si invia un lavoro e pertanto non si dovrebbe utilizzare un thread thread cercando di aggirare lo ExecutorService che potrebbe non essere affatto divertito. Chiamando il numero Future.cancel(true) dai a tutte le parti coinvolte un segnale chiaro su cosa fare.