Interface ExecutorService

Pourquoi avez-vous besoin de l'interface Executor ?

Avant Java 5, vous deviez écrire toute votre propre gestion des threads de code dans votre application. De plus, la création d'unnouveau filL'objet est une opération gourmande en ressources et cela n'a pas de sens de créer un nouveau thread pour chaque tâche légère. Et parce que ce problème est familier à absolument tous les développeurs d'applications multithreads, ils ont décidé d'intégrer cette fonctionnalité dans Java en tant que framework Executor .

Quelle est la grande idée ? C'est simple : au lieu de créer un nouveau thread pour chaque nouvelle tâche, les threads sont conservés dans une sorte de "stockage", et lorsqu'une nouvelle tâche arrive, on récupère un thread existant au lieu d'en créer un nouveau.

Les principales interfaces de ce framework sont Executor , ExecutorService et ScheduledExecutorService , chacune étendant les fonctionnalités de la précédente.

L'interface Executor est l'interface de base. Il déclare une seule méthode void execute(Runnable command) qui est implémentée par un objet Runnable .

L' interface ExecutorService est plus intéressante. Il a des méthodes pour gérer l'achèvement du travail, ainsi que des méthodes pour renvoyer une sorte de résultat. Examinons de plus près ses méthodes :

Regardons un petit exemple de travail avec ExecutorService .

import java.util.List;
import java.util.concurrent.*;

public class ExecutorServiceTest {
   public static void main(String[] args) throws InterruptedException, ExecutionException, TimeoutException {
//Create an ExecutorService for 2 threads
       java.util.concurrent.ExecutorService executorService = new ThreadPoolExecutor(2, 2, 60, TimeUnit.SECONDS, new ArrayBlockingQueue<>(10));
// Create 5 tasks
       MyRunnable task1 = new MyRunnable();
       MyRunnable task2 = new MyRunnable();
       MyRunnable task3 = new MyRunnable();
       MyRunnable task4 = new MyRunnable();
       MyRunnable task5 = new MyRunnable();

       final List<MyRunnable> tasks = List.of(task1, task2, task3, task4, task5);
// Pass a list that contains the 5 tasks we created
       final List<Future<Void>> futures = executorService.invokeAll(tasks, 6, TimeUnit.SECONDS);
       System.out.println("Futures received");

// Stop the ExecutorService
       executorService.shutdown();

       try {
           TimeUnit.SECONDS.sleep(3);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }

       System.out.println(executorService.isShutdown());
       System.out.println(executorService.isTerminated());
   }

   public static class MyRunnable implements Callable<Void> {

       @Override
       public void call() {
// Add 2 delays. When the ExecutorService is stopped, we will see which delay is in progress when the attempt is made to stop execution of the task
           try {
               TimeUnit.SECONDS.sleep(3);
           } catch (InterruptedException e) {
               System.out.println("sleep 1: " + e.getMessage());
           }
           try {
               TimeUnit.SECONDS.sleep(2);
           } catch (InterruptedException e) {
               System.out.println("sleep 2: " + e.getMessage());
           }
           System.out.println("done");
           return null;
       }
   }
}

Sortir:

Chaque tâche s'exécute pendant 5 secondes. Nous avons créé un pool pour deux threads, donc les deux premières lignes de sortie sont parfaitement logiques.

Six secondes après le démarrage du programme, la méthode invokeAll expire et le résultat est renvoyé sous la forme d'une liste de Futures . Cela peut être vu à partir de la chaîne de sortie Futures receive .

Une fois les deux premières tâches terminées, deux autres commencent. Mais comme le délai d'attente défini dans la méthode invokeAll expire, ces deux tâches n'ont pas le temps de se terminer. Ils reçoivent une commande "annuler" . C'est pourquoi la sortie comporte deux lignes avec sleep 1 : sleep interruption .

Et puis vous pouvez voir deux autres lignes avec done . C'est l'effet secondaire que j'ai mentionné lors de la description de la méthode invokeAll .

La cinquième et dernière tâche ne démarre même jamais, nous ne voyons donc rien à ce sujet dans la sortie.

Les deux dernières lignes sont le résultat de l'appel des méthodes isShutdown et isTerminated .

Il est également intéressant d'exécuter cet exemple en mode débogage et de regarder l'état de la tâche une fois le délai écoulé (définissez un point d'arrêt sur la ligne avec executorService.shutdown(); ) :

Nous voyons que deux tâches se sont terminées normalement et que trois tâches ont été "annulées" .

ScheduledExecutorService

Pour conclure notre discussion sur les exécuteurs, examinons ScheduledExecutorService .

Il dispose de 4 méthodes :