Una guida a Java ExecutorService

1. Panoramica

ExecutorService è un framework fornito da JDK che semplifica l'esecuzione delle attività in modalità asincrona. In generale, ExecutorService fornisce automaticamente un pool di thread e API per l'assegnazione di attività.

2. Creazione di un'istanza di ExecutorService

2.1. Metodi di fabbrica della classe Executors

Il modo più semplice per creare ExecutorService consiste nell'usare uno dei metodi factory della classe Executors .

Ad esempio, la seguente riga di codice creerà un pool di thread con 10 thread:

ExecutorService executor = Executors.newFixedThreadPool(10);

Ci sono molti altri metodi di fabbrica per creare ExecutorService predefiniti che soddisfano casi d'uso specifici. Per trovare il metodo migliore per le tue esigenze, consulta la documentazione ufficiale di Oracle.

2.2. Crea direttamente un ExecutorService

Poiché ExecutorService è un'interfaccia, è possibile utilizzare un'istanza di qualsiasi sua implementazione. Esistono diverse implementazioni tra cui scegliere nel pacchetto java.util.concurrent oppure puoi crearne una tua.

Ad esempio, la classe ThreadPoolExecutor ha alcuni costruttori che possono essere utilizzati per configurare un servizio esecutore e il relativo pool interno.

ExecutorService executorService = new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue());

Potresti notare che il codice sopra è molto simile al codice sorgente del metodo di fabbrica newSingleThreadExecutor (). Nella maggior parte dei casi, non è necessaria una configurazione manuale dettagliata.

3. Assegnazione di attività a ExecutorService

ExecutorService può eseguire Runnable e Callable compiti. Per mantenere le cose semplici in questo articolo, verranno utilizzate due attività primitive. Si noti che le espressioni lambda vengono utilizzate qui invece di classi interne anonime:

Runnable runnableTask = () -> { try { TimeUnit.MILLISECONDS.sleep(300); } catch (InterruptedException e) { e.printStackTrace(); } }; Callable callableTask = () -> { TimeUnit.MILLISECONDS.sleep(300); return "Task's execution"; }; List
    
      callableTasks = new ArrayList(); callableTasks.add(callableTask); callableTasks.add(callableTask); callableTasks.add(callableTask);
    

Le attività possono essere assegnate a ExecutorService utilizzando diversi metodi, tra cui execute () , che viene ereditato dall'interfaccia Executor , e anche submit () , invokeAny (), invokeAll ().

Il metodo execute () è void e non dà alcuna possibilità di ottenere il risultato dell'esecuzione dell'attività o di controllare lo stato dell'attività (è in esecuzione o eseguita).

executorService.execute(runnableTask);

submit () invia un'attività Callable o Runnable a un ExecutorService e restituisce un risultato di tipo Future .

Future future = executorService.submit(callableTask);

invokeAny () assegna una raccolta di attività a un ExecutorService, provocandone l'esecuzione e restituisce il risultato dell'esecuzione riuscita di un'attività (se è stata eseguita correttamente) .

String result = executorService.invokeAny(callableTasks);

invokeAll () assegna una raccolta di attività a un ExecutorService, provocandone l'esecuzione e restituisce il risultato di tutte le esecuzioni delle attività sotto forma di un elenco di oggetti di tipo Future .

List
    
      futures = executorService.invokeAll(callableTasks);
    

Ora, prima di andare oltre, è necessario discutere altre due cose: chiudere un ExecutorService e gestire i tipi di ritorno Future .

4. Chiusura di un ExecutorService

In generale, ExecutorService non verrà automaticamente distrutto quando non ci sono attività da elaborare. Rimarrà in vita e aspetterà il nuovo lavoro da fare.

In alcuni casi questo è molto utile; ad esempio, se un'app deve elaborare attività che appaiono su base irregolare o la quantità di queste attività non è nota al momento della compilazione.

D'altra parte, un'app potrebbe raggiungere la fine, ma non verrà interrotta perché un ExecutorService in attesa farà sì che la JVM continui a funzionare.

Per chiudere correttamente un ExecutorService , abbiamo le API shutdown () e shutdownNow () .

Il metodo shutdown () non causa la distruzione immediata di ExecutorService. Farà sì che ExecutorService smetta di accettare nuove attività e si spenga dopo che tutti i thread in esecuzione hanno terminato il loro lavoro corrente.

executorService.shutdown();

Il metodo shutdownNow () tenta di distruggere immediatamente ExecutorService , ma non garantisce che tutti i thread in esecuzione verranno arrestati contemporaneamente. Questo metodo restituisce un elenco di attività in attesa di essere elaborate. Spetta allo sviluppatore decidere cosa fare con queste attività.

List notExecutedTasks = executorService.shutDownNow();

Un buon modo per chiudere ExecutorService (consigliato anche da Oracle) è utilizzare entrambi questi metodi in combinazione con il metodo awaitTermination () . Con questo approccio, ExecutorService interromperà prima l'esecuzione di nuove attività, quindi attenderà fino a un periodo di tempo specificato per il completamento di tutte le attività. Se questo tempo scade, l'esecuzione viene interrotta immediatamente:

executorService.shutdown(); try { if (!executorService.awaitTermination(800, TimeUnit.MILLISECONDS)) { executorService.shutdownNow(); } } catch (InterruptedException e) { executorService.shutdownNow(); }

5. L' interfaccia futura

The submit() and invokeAll() methods return an object or a collection of objects of type Future, which allows us to get the result of a task's execution or to check the task's status (is it running or executed).

The Future interface provides a special blocking method get() which returns an actual result of the Callable task's execution or null in the case of Runnable task. Calling the get() method while the task is still running will cause execution to block until the task is properly executed and the result is available.

Future future = executorService.submit(callableTask); String result = null; try { result = future.get(); } catch (InterruptedException | ExecutionException e) { e.printStackTrace(); }

With very long blocking caused by the get() method, an application's performance can degrade. If the resulting data is not crucial, it is possible to avoid such a problem by using timeouts:

String result = future.get(200, TimeUnit.MILLISECONDS);

If the execution period is longer than specified (in this case 200 milliseconds), a TimeoutException will be thrown.

The isDone() method can be used to check if the assigned task is already processed or not.

The Future interface also provides for the cancellation of task execution with the cancel() method, and to check the cancellation with isCancelled() method:

boolean canceled = future.cancel(true); boolean isCancelled = future.isCancelled();

6. The ScheduledExecutorService Interface

The ScheduledExecutorService runs tasks after some predefined delay and/or periodically. Once again, the best way to instantiate a ScheduledExecutorService is to use the factory methods of the Executors class.

For this section, a ScheduledExecutorService with one thread will be used:

ScheduledExecutorService executorService = Executors .newSingleThreadScheduledExecutor();

To schedule a single task's execution after a fixed delay, us the scheduled() method of the ScheduledExecutorService. There are two scheduled() methods that allow you to execute Runnable or Callable tasks:

Future resultFuture = executorService.schedule(callableTask, 1, TimeUnit.SECONDS);

The scheduleAtFixedRate() method lets execute a task periodically after a fixed delay. The code above delays for one second before executing callableTask.

The following block of code will execute a task after an initial delay of 100 milliseconds, and after that, it will execute the same task every 450 milliseconds. If the processor needs more time to execute an assigned task than the period parameter of the scheduleAtFixedRate() method, the ScheduledExecutorService will wait until the current task is completed before starting the next:

Future resultFuture = service .scheduleAtFixedRate(runnableTask, 100, 450, TimeUnit.MILLISECONDS);

If it is necessary to have a fixed length delay between iterations of the task, scheduleWithFixedDelay() should be used. For example, the following code will guarantee a 150-millisecond pause between the end of the current execution and the start of another one.

service.scheduleWithFixedDelay(task, 100, 150, TimeUnit.MILLISECONDS);

According to the scheduleAtFixedRate() and scheduleWithFixedDelay() method contracts, period execution of the task will end at the termination of the ExecutorService or if an exception is thrown during task execution.

7. ExecutorService vs. Fork/Join

After the release of Java 7, many developers decided that the ExecutorService framework should be replaced by the fork/join framework. This is not always the right decision, however. Despite the simplicity of usage and the frequent performance gains associated with fork/join, there is also a reduction in the amount of developer control over concurrent execution.

ExecutorService gives the developer the ability to control the number of generated threads and the granularity of tasks which should be executed by separate threads. The best use case for ExecutorService is the processing of independent tasks, such as transactions or requests according to the scheme “one thread for one task.”

In contrast, according to Oracle's documentation, fork/join was designed to speed up work which can be broken into smaller pieces recursively.

8. Conclusion

Even despite the relative simplicity of ExecutorService, there are a few common pitfalls. Let's summarize them:

Keeping an unused ExecutorService alive: There is a detailed explanation in section 4 of this article about how to shut down an ExecutorService;

Wrong thread-pool capacity while using fixed length thread-pool: It is very important to determine how many threads the application will need to execute tasks efficiently. A thread-pool that is too large will cause unnecessary overhead just to create threads which mostly will be in the waiting mode. Too few can make an application seem unresponsive because of long waiting periods for tasks in the queue;

Calling a Future‘s get() method after task cancellation: An attempt to get the result of an already canceled task will trigger a CancellationException.

Unexpectedly-long blocking with Future‘s get() method: Timeouts should be used to avoid unexpected waits.

Il codice per questo articolo è disponibile in un repository GitHub.