Come spegnere tutti gli Executor quando si esce da un'applicazione?

Question

Secondo Concurrency in Practice di Brian Goetz JVM non può essere terminato fino a quando tutti i thread (nondaemon) non sono terminati, quindi non riuscire a arrestare un Executor potrebbe impedire l'uscita dalla JVM.

I.e. System.exit (0) non funziona necessariamente come previsto se ci sono Executor in giro. Sembrerebbe necessario mettere un qualche tipo di

public void stop() { exec.shutdown() } 

metodi per tutte le classi che contengono Esecutori, e poi li chiamo quando l'applicazione è in procinto di terminare. È questo l'unico modo, o c'è una sorta di scorciatoia per chiudere tutti gli Executor?

Answer 1

Non esiste una scorciatoia per eseguirli tutti, no. Inoltre, dovresti probabilmente chiamare shutdownNow() anziché shutdown(), altrimenti potresti aspettare un po '.

Quello che potresti fare, suppongo, è quando crei l'Esecutore, registrarlo in un posto centrale. Quindi, al momento dello spegnimento, è sufficiente chiamare lo shutdown() su quell'oggetto centrale, che a sua volta potrebbe terminare ciascuno degli esecutori registrati.

Se si utilizza Spring, è possibile sfruttare i bean di fabbrica che creano e gestiscono gli Executor per conto dell'utente. Questo include chiuderli con grazia quando l'applicazione si chiude, e ti risparmia di doverli gestire da solo.

Answer 2

Probabilmente intendeva dire che JVM non può fermarsi da solo fino a quando i thread nondaemon non sono terminati. È come eseguire una semplice classe da comando come java SomeClass e dopo l'esecuzione del metodo principale, JVM si ferma.

System.exit è un comando di terminazione JVM, anche se i thread daemon sono in esecuzione, JVM verrà arrestato.

Answer 3

È inoltre possibile fornire un'implementazione di ThreadFactory che contrassegna i thread creati come thread daemon. Preferisco un meccanismo di arresto pulito (con i metodi del ciclo di vita), ma ci sono casi in cui non è necessario garantire lo stato/completamento di attività non completate quando questo può essere appropriato.

Answer 4

Per impostazione predefinita, un Executor creerà solo thread non daemon. È possibile sovrascriverlo fornendo l'Executor con il proprio ThreadFactory. Ecco un esempio:

class DaemonThreadFactory implements ThreadFactory { 
    public Thread newThread(Runnable r) { 
    Thread t = new Thread(r); 
    t.setDaemon(true); 
    return t; 
    } 
} 

essere cauti, però, perché la JVM uscirà subito anche se questi fili sono occupati a fare un lavoro utile!

Answer 5

decorare l'esecutore con com.google.common.util.concurrent.MoreExecutors#getExitingExecutorService

@Beta 
public static ExecutorService getExitingExecutorService(ThreadPoolExecutor executor, 
             long terminationTimeout, 
             TimeUnit timeUnit) 

converte le ThreadPoolExecutor in un ExecutorService che esce quando l'applicazione è completa. Lo fa usando i thread di daemon e aggiungendo un hook di shutdown per attendere il loro completamento.

Si tratta principalmente di pool di thread fissi. Vedi Executors.newFixedThreadPool (int).