Services d'exécuteur testamentaire

Exécuteur

Executor est l'interface de base pour les classes qui implémente le lancement de tâches Runnable . Cela fournit une assistance pour ajouter une tâche et comment la démarrer.

ExecutorService est une interface qui étend les propriétés de Executor et qui décrit un service pour exécuter des tâches Runnable ou Callable . Les méthodes submit acceptent une tâche sous la forme d' un Callable ou Runnable comme input , et un Future est utilisé comme valeur de retour, à travers laquelle vous pouvez obtenir le résultat.

La méthode invokeAll est responsable de l'exécution des tâches, renvoyant une liste de tâches avec leur statut et les résultats de leur achèvement.

La méthode beginAny est responsable de l'exécution des tâches, renvoyant le résultat d'une tâche terminée avec succès (c'est-à-dire sans lever d'exception), le cas échéant.

ScheduledExecutorService - cette interface ajoute la possibilité d'exécuter des tâches en attente avec un certain retard ou une certaine période.

AbstractExecutorService est une classe abstraite pour construire un ExecutorService 'a. À l'intérieur, il y a une implémentation des méthodes submit , invokeAll , invokeAny . Cette classe hérite de ThreadPoolExecutor , ScheduledThreadPoolExecutor et ForkJoinPool .

public static void main(String[] args) {
   ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(1);
   Callable<String> task = () -> {
       System.out.println(Thread.currentThread().getName());
       return Thread.currentThread().getName();
   };
   scheduledExecutorService.schedule(task, 10, TimeUnit.SECONDS);
   scheduledExecutorService.shutdown();
}

ThreadPoolExecutor

Executors est une classe de fabrique permettant de créer ThreadPoolExecutor , ScheduledThreadPoolExecutor . Si vous avez besoin de créer l'un de ces pools, cette usine est exactement ce dont vous avez besoin. Il contient différents adaptateurs Runnable-Callable, PrivilegedAction-Callable, PrivilegedExceptionAction-Callable et autres. Possède des méthodes statiques pour créer différents ThreadPool .

ThreadPoolExecutor - Implémente les interfaces Executor et ExecutorService et sépare la création de tâche de l'exécution de tâche. Nous devons implémenter des objets Runnable et les envoyer à l'exécuteur, et ThreadPoolExecutor est responsable de leur exécution, de leur instanciation et du travail avec les threads.

ScheduledThreadPoolExecutor - En plus des méthodes ThreadPoolExecutor , il crée un pool de threads qui peuvent planifier l'exécution de commandes après un délai donné ou pour une exécution périodique.

ThreadFactoryest un objet qui crée de nouveaux threads à la demande. Nous devons passer une instance à la méthode Executors.newSingleThreadExecutor(ThreadFactory threadFactory) .

ExecutorService executorService = Executors.newSingleThreadExecutor(new ThreadFactory() {
 @Override public Thread newThread(Runnable r) {
Thread thread = new Thread(r, "MyThread");
thread.setPriority(Thread.MAX_PRIORITY);
 return thread; }
 });

RejectedExecutionHandler - vous permet de définir un gestionnaire pour les tâches qui, pour une raison quelconque, ne peuvent pas être exécutées via le ThreadPoolExecutor . Cela se produit lorsqu'il n'y a pas de flux gratuits ou que le service est arrêté ou arrêté.

Plusieurs implémentations standard se trouvent dans la classe ThreadPoolExecutor :

• CallerRunsPolicy - exécute une tâche sur le thread appelant ;
• AbortPolicy - lève une exception ;
• DiscardPolicy - ignore la tâche ;
• DiscardOldestPolicy - Supprime la plus ancienne tâche non démarrée de la file d'attente, puis tente à nouveau d'ajouter une nouvelle tâche.

Service d'achèvement

CompletionService est une interface de service découplant le lancement de tâches asynchrones et l'obtention de résultats. Pour ajouter des tâches, il existe une méthodesubmit, et pour obtenir les résultats des tâches déjà terminées, unetakepollnon bloquante.

ExecutorCompletionService est un wrapper sur toute classe qui implémente l'interface Executor , telle que ThreadPoolExecutor ou ForkJoinPool . Il est utilisé lorsqu'il est nécessaire de faire abstraction de la méthode de lancement des tâches et de contrôle de leur exécution.

S'il y a des tâches terminées, nous les retirons. S'il n'y a pas de tâches, nous nous accrochons jusqu'à ce que quelque chose soit terminé. Le service utilise une LinkedBlockingQueue en son cœur, mais vous pouvez transmettre n'importe quelle implémentation de BlockingQueue.