Un guide sur Java ExecutorService

1. Vue d'ensemble

ExecutorService est un framework fourni par le JDK qui simplifie l'exécution des tâches en mode asynchrone. De manière générale, ExecutorService fournit automatiquement un pool de threads et d'API pour lui attribuer des tâches.

2. Instanciation d' ExecutorService

2.1. Méthodes d'usine de la classe Executors

Le moyen le plus simple de créer ExecutorService consiste à utiliser l'une des méthodes de fabrique de la classe Executors .

Par exemple, la ligne de code suivante créera un pool de threads avec 10 threads:

ExecutorService executor = Executors.newFixedThreadPool(10);

Il existe plusieurs autres méthodes d'usine pour créer des ExecutorService prédéfinis qui répondent à des cas d'utilisation spécifiques. Pour trouver la meilleure méthode pour vos besoins, consultez la documentation officielle d'Oracle.

2.2. Créer directement un ExecutorService

Étant donné qu'ExecutorService est une interface, une instance de ses implémentations peut être utilisée. Vous avez le choix entre plusieurs implémentations dans le package java.util.concurrent ou vous pouvez créer la vôtre.

Par exemple, la classe ThreadPoolExecutor a quelques constructeurs qui peuvent être utilisés pour configurer un service exécuteur et son pool interne.

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

Vous pouvez remarquer que le code ci-dessus est très similaire au code source de la méthode d'usine newSingleThreadExecutor (). Dans la plupart des cas, une configuration manuelle détaillée n'est pas nécessaire.

3. Attribution de tâches à ExecutorService

ExecutorService peut exécuter des tâches exécutables et appelables . Pour simplifier les choses dans cet article, deux tâches primitives seront utilisées. Notez que les expressions lambda sont utilisées ici au lieu des classes internes anonymes:

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);
    

Les tâches peuvent être assignées à ExecutorService à l' aide de plusieurs méthodes, notamment execute () , qui est héritée de l' interface Executor , et également submit () , invokeAny (), invokeAll ().

La méthode execute () est void et ne donne aucune possibilité d'obtenir le résultat de l'exécution de la tâche ou de vérifier l'état de la tâche (est-elle en cours d'exécution ou exécutée).

executorService.execute(runnableTask);

submit () soumet unetâche Callable ou Runnable à un ExecutorService et renvoie un résultat de type Future .

Future future = executorService.submit(callableTask);

invokeAny () assigne une collection de tâches à un ExecutorService, provoquant l'exécution de chacune d'entre elles, et retourne le résultat d'une exécution réussie d'une tâche (s'il y a eu une exécution réussie) .

String result = executorService.invokeAny(callableTasks);

invokeAll () affecte une collection de tâches à un ExecutorService, provoquant l'exécution de chacune d'entre elles, et renvoie le résultat de toutes les exécutions de tâches sous la forme d'une liste d'objets de type Future .

List
    
      futures = executorService.invokeAll(callableTasks);
    

Maintenant, avant d'aller plus loin, deux autres choses doivent être discutées: l'arrêt d'un ExecutorService et le traitement des types de retour Future .

4. Arrêt d'un ExecutorService

En général, ExecutorService ne sera pas automatiquement détruit lorsqu'il n'y a aucune tâche à traiter. Il restera en vie et attendra un nouveau travail.

Dans certains cas, cela est très utile; par exemple, si une application doit traiter des tâches qui apparaissent de manière irrégulière ou si la quantité de ces tâches n'est pas connue au moment de la compilation.

D'un autre côté, une application pourrait atteindre sa fin, mais elle ne sera pas arrêtée car un ExecutorService en attente entraînera la poursuite de l'exécution de la JVM.

Pour arrêter correctement un ExecutorService , nous avons les API shutdown () et shutdownNow () .

La méthode shutdown () ne provoque pas la destruction immédiate de l' ExecutorService. Cela empêchera ExecutorService d' accepter de nouvelles tâches et s'arrêtera une fois que tous les threads en cours d'exécution auront terminé leur travail actuel.

executorService.shutdown();

La méthode shutdownNow () essaie de détruire immédiatement ExecutorService , mais elle ne garantit pas que tous les threads en cours d'exécution seront arrêtés en même temps. Cette méthode renvoie une liste de tâches en attente de traitement. Il appartient au développeur de décider quoi faire de ces tâches.

List notExecutedTasks = executorService.shutDownNow();

Un bon moyen d'arrêter ExecutorService (qui est également recommandé par Oracle) est d'utiliser ces deux méthodes combinées avec la méthode awaitTermination () . Avec cette approche, ExecutorService arrêtera d'abord de prendre de nouvelles tâches, puis attendra jusqu'à une période de temps spécifiée pour que toutes les tâches soient terminées. Si ce délai expire, l'exécution est immédiatement arrêtée:

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

5. L' interface future

Les méthodes submit () et invokeAll () retournent un objet ou une collection d'objets de type Future , ce qui nous permet d'obtenir le résultat de l'exécution d'une tâche ou de vérifier l'état de la tâche (est-elle en cours d'exécution ou exécutée).

L' interface Future fournit une méthode de blocage spéciale get () qui retourne un résultat réel de l' exécution de la tâche Callable ou null dans le cas de la tâche Runnable . L'appel de la méthode get () alors que la tâche est toujours en cours d'exécution bloquera l'exécution jusqu'à ce que la tâche soit correctement exécutée et que le résultat soit disponible.

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.

Le code de cet article est disponible dans un référentiel GitHub.