So beenden Sie den aufrufbaren Prozess, der von ExecutorService aufgerufen wird

Question

Im folgenden Code möchte ich den Callable-Prozess beenden, der von ExecutorService übergeben wurde. Derzeit wird die Ausführung des aufrufbaren Prozesses nicht beendet, obwohl das Herunterfahren vor der Schleifenausführung aufgerufen wurde.

Jeder Vorschlag wäre hilfreich.

package foundation.util.sql.parser; 

import java.io.IOException; 
import java.util.HashMap; 
import java.util.concurrent.*; 

public class Test { 

    public static void main(String[] args) { 
     try { 

      final java.util.Map<String, ExecutorService> map = new HashMap<>(); 
      ExecutorService service = Executors.newFixedThreadPool(1); 
      map.put("1", service); 
Thread thread = new Thread(new Runnable() { 

       @Override 
       public void run() { 
        try { 

         System.out.println("Termination Initiated"); 
         ExecutorService executorService = map.get("1"); 
         System.out.println("ShutDown called"); 

         if(!executorService.isShutdown()) 
         { 
          executorService.shutdownNow(); 
         } 
        } catch (Exception e) { 
         e.printStackTrace(); 
        } 
       } 
      }); 
      Future<Boolean> submit = service.submit(new Callable<Boolean>() { 

       @Override 
       public Boolean call() throws Exception { 
        int j = 0; 
        System.out.println(Thread.currentThread().getName()); 
        for (int i=0; i<5000;i++) { 
         //Some business Process. 
         j = i; 
        } 
        System.out.println("Test____"+ j); 
        return null; 
       } 
      }); 
      thread.start(); 
      submit.get(); 
     } catch (Exception e) { 
      e.printStackTrace(); 
     } 
    } 

} 

Answer 1

Wenn wir showDownNow() nennen es nicht die laufenden Aufgaben beenden, in der Tat

es verhindert nur warten Aufgaben von Start und Versuche zur Zeit zu stoppen Aufgaben ausführt.

Per javadoc

Es gibt keine Garantien über Best-Effort versucht Verarbeitung aktiv zu stoppen Aufgaben ausführt. Zum Beispiel werden typische Implementierungen über Thread.interrupt(), abgebrochen, so dass jede Aufgabe, die nicht auf Interrupts reagiert, niemals beendet wird.

In Ihrem aufrufbar sind Sie nicht für das Interrupts reagiert/Überprüfung. Sie müssen regelmäßig überprüfen, ob interrupt flag auf "True" gesetzt ist. Wenn dies der Fall ist, führen Sie die notwendigen Säuberungen durch, falls erforderlich, und beenden Sie sie.

Als Beispiel in Ihrem Fall können Sie die interrupt flag Überprüfung betrachten, wie unten (oder wo auch immer anwendbar):

for (int i=0; i<5000;i++) { 
    //Some business Process. 
    if(Thread.currentThread().isInterrupted()) { 
    // do any cleanup and return from here. 
    return false; 
    } 
    j = i; 
}