Come viene ucciso un threadPoolExecutor con i thread "Occupati"?

Question

La mia domanda è leggermente complicata. Lascia che provi a spiegarlo a fondo, ma se hai bisogno di maggiori dettagli, sentiti libero di chiedermelo, li aggiungerò.

Ho appreso di recente (tramite esperimento) che se un thread esegue continuamente il lavoro, qualcosa come un'operazione intera in un ciclo while (vero), l'interruzione del thread non ha alcun effetto su di esso. La discussione continua come se nulla fosse accaduto.

Ora, ThreadPoolExecutors viene ucciso utilizzando i metodi shutDown() o shutDownNow(). Ho controllato il codice per questi metodi, usano la chiamata interrupt() per uccidere un thread. Quindi, se tutti i thread sono impegnati a fare cose, come si ucciderà un esecutore? Come viene ucciso, ad esempio quando lo utilizziamo nelle app di primavera.

Una tale esecutore sarà simile:

import java.io.File; 
import java.io.IOException; 
import java.util.concurrent.ExecutorService; 
import java.util.concurrent.Executors; 

public class Test { 
    public static void main(String[] a) { 
     ExecutorService ex = Executors.newFixedThreadPool(50); 
     for (int i = 0; i < 50; i++) { 
      ex.execute(new Thread() { 
       public void run() { 
        try { 
         File f = File.createTempFile("testfile", "txt"); 
         while (true) { 
          f.canRead(); 
         } 
        } catch (IOException e) { 
         // TODO Auto-generated catch block 
         e.printStackTrace(); 
        } finally { 
        } 
       } 
      }); 
     } 

     ex.shutdown(); 
     ex.shutdownNow(); 
    } 
} 

Answer 1

Per rispondere alla tua domanda principale, non sarebbe, non meno che la JVM è stato detto esplicitamente di uscita via System.exit().

Per le operazioni di lunga durata che devono essere interrompibili, è responsabilità dell'implementazione controllare il flag di interrupt tramite Thread.currentThread().isInterrupted().

Ad esempio:

import java.io.File; 
import java.io.IOException; 
import java.util.concurrent.ExecutorService; 
import java.util.concurrent.Executors; 

public class Test { 
    public static void main(String[] a) { 
     ExecutorService ex = Executors.newFixedThreadPool(50); 
     for (int i = 0; i < 50; i++) { 
      ex.execute(new Runnable() { 
       public void run() { 
        try { 
         File f = File.createTempFile("testfile", "txt"); 
         while (!Thread.currentThread().isInterrupted()) { 
          f.canRead(); 
         } 
        } catch (IOException e) { 
         // TODO Auto-generated catch block 
         e.printStackTrace(); 
        } finally { 
        } 
       } 
      }); 
     } 

     ex.shutdown(); 
     ex.shutdownNow(); 
    } 
} 

noti inoltre che non è adatto per creare un'istanza di Thread destinate esclusivamente come Runnable. In questo modo si crea una sorta di indirezione che potrebbe confondere i programmatori più ingenui.

Answer 2

Non si dovrebbe essere avere un ciclo infinate nel codice.

Il pool di thread non attende l'uscita dei thread.

Il filo durerà per sempre fino a quando la JVM esce