Java ExecutorService è l'interfaccia che ci consente di eseguire attività sui thread in modo asincrono. L'interfaccia Java ExecutorService è presente nel pacchetto java.util.concurrent. ExecutorService aiuta a mantenere un pool di thread e assegna loro attività. Fornisce inoltre la possibilità di mettere in coda le attività finché non è disponibile un thread libero se il numero di attività è superiore ai thread disponibili.

Metodi di Java ExecutorService

Un semplice programma di Java ExecutorService

 public class ExecutorServiceExample { public static void main(String[] args) { ExecutorService executorService = Executors.newFixedThreadPool(10); executorService.execute(new Runnable() { @Override public void run() { System.out.println('ExecutorService'); } }); executorService.shutdown(); } } 

Produzione:

In questo programma, stiamo creando un ExecutorService con dieci thread e assegnandogli un'implementazione eseguibile anonima che esegue un'attività per stampare 'ExecutorService' e al termine della sua attività, stiamo chiudendo il servizio dell'esecutore.

Come utilizzare Java ExecutorService

Istanziazione di ExecutorService

Possiamo utilizzare Java ExecutorService per creare un singolo thread, un pool di thread o un pool di thread pianificato. La classe Executors fornisce metodi factory per istanziare un ExecutorService come segue:

 ExecutorService executorService1 = Executors.newSingleThreadExecutor(); //Creates //a ExecutorService object having a single thread. ExecutorService executorService2 = Executors.newFixedThreadPool(10); // Creates a //ExecutorService object having a pool of 10 threads. ExecutorService executorService3 = Executors.newScheduledThreadPool(10); //Creates a scheduled thread pool executor with 10 threads. In scheduled thread //pool, we can schedule tasks of the threads. 

Assegnazione di attività a ExecutorServices

Per assegnare un'attività a ExecutorService, possiamo utilizzare i seguenti metodi:

• eseguire(attività eseguibile)
• invia(attività eseguibile) / invia(attività richiamabile)
• invocareAny(Collezionecompiti)
• invocaAll(Collezionecompiti)

Esempio di assegnazione di un'attività a ExecutorService utilizzando il metodoexe()

Il metodoexecute() di Java ExecutorService accetta un oggetto eseguibile ed esegue la sua attività in modo asincrono. Dopo aver effettuato la chiamata al metodo di esecuzione, chiamiamo il metodo shutdown, che blocca qualsiasi altra attività in coda nell'executorService.

forme normali

 public class ExecutorServiceExample { public static void main(String[] args) { ExecutorService executorService = Executors.newSingleThreadExecutor(); executorService.execute(new Runnable() { @Override public void run() { System.out.println('ExecutorService'); } }); executorService.shutdown(); } } 

Produzione:

 ExecutorService 

Esempio di assegnazione di un'attività a ExecutorService utilizzando send()

Il metodo send() accetta un oggetto eseguibile e restituisce un oggetto Future. Questo oggetto viene successivamente utilizzato per verificare lo stato di Runnable se ha completato l'esecuzione o meno.

 public class ExecutorServiceExample { public static void main(String[] args) { ExecutorService executorService = Executors.newSingleThreadExecutor(); executorService.submit(new Runnable() { @Override public void run() { System.out.println('ExecutorService'); } }); } } 

Esempio di assegnazione di un'attività a ExecutorService utilizzando il metodo invokeAny()

contiene in stringa

Il metodo invokeAny() accetta una raccolta di oggetti Callablle o oggetti di classi che implementano Callable. Questo metodo restituisce l'oggetto futuro dell'oggetto richiamabile che viene eseguito per primo con successo.

 public class ExecutorServiceExample { public static void main(String[] args) throws InterruptedException, ExecutionException { ExecutorService executorService = Executors.newSingleThreadExecutor(); Set<callable> callables = new HashSet<callable>(); callables.add(new Callable() { public String call() throws Exception { return &apos;Task 1&apos;; } }); callables.add(new Callable() { public String call() throws Exception { return &apos;Task 2&apos;; } }); callables.add(new Callable() { public String call() throws Exception { return &apos;Task 3&apos;; } }); String result = executorService.invokeAny(callables); System.out.println(&apos;result = &apos; + result); executorService.shutdown(); } } </callable></callable>

Produzione:

 result = Task 1 

Il risultato memorizza l'attività 1 poiché il primo oggetto richiamabile viene eseguito correttamente per primo.

Esempio di assegnazione di un'attività a ExecutorService utilizzando il metodo invokeAll()

Il metodo invokeAll() accetta una raccolta di oggetti Callable con attività e restituisce un elenco di oggetti Future contenente il risultato di tutte le attività.

 public class ExecutorServiceExample { public static void main(String[] args) throws InterruptedException, ExecutionException { ExecutorService executorService = Executors.newSingleThreadExecutor(); Set<callable> callables = new HashSet<callable>(); callables.add(new Callable() { public String call() throws Exception { return &apos;Task 1&apos;; } }); callables.add(new Callable() { public String call() throws Exception { return &apos;Task 2&apos;; } }); callables.add(new Callable() { public String call() throws Exception { return &apos;Task 3&apos;; } }); java.util.List<future> futures = executorService.invokeAll(callables); for(Future future : futures){ System.out.println(&apos;future.get = &apos; + future.get()); } executorService.shutdown(); } } </future></callable></callable>

Produzione:

 future.get = Task 1 future.get = Task 3 future.get = Task 2 

Come chiudere ExecutorService

Una volta completate le attività assegnate a ExecutorService, dobbiamo chiuderlo perché ExecutorService esegue l'attività su thread diversi. Se non chiudiamo ExecutorService, i thread continueranno a funzionare e la JVM non si spegnerà.

Il processo di spegnimento può essere eseguito con i seguenti tre metodi:

• metodo shutdown()
• metodo shutdownNow()
• metodo waitTermination()