Présentation du service Executor en Java

Les API Executor et ExecutorService sont un outil crucial pour gérer et contrôler l'exécution des threads. Ils font partie du package java.util.concurrent. Ils simplifient le processus de programmation simultanée en éliminant les complexités de la création, de la gestion et de la synchronisation des threads.

Executors est une classe utilitaire du package java.util.concurrent qui fournit des méthodes d'usine pour créer et gérer différents types d'instances ExecutorService. Il simplifie le processus de création de pools de threads et nous permet de créer et de gérer facilement des instances d'exécuteur avec différentes configurations.

API Executor C'est une interface disponible depuis Java 1.5. Il fournit la méthode d'exécution (commande Runnable). Il s'agit de l'interface de base et ExecutorService étend cette interface. La commande donnée sera exécutée ultérieurement par un nouveau thread ou un thread du pool de threads ou du même thread et ne renvoie pas void.

API ExecutorService C'est une interface disponible depuis Java 1.5. Il fournit plusieurs méthodes pour contrôler l’exécution des tâches en programmation simultanée. Il prend en charge les tâches exécutables et appelables. Il renvoie Future pour le statut de la tâche. Vous trouverez ci-dessous les méthodes les plus fréquemment utilisées.

• submit() accepte une tâche Callable ou Runnable et renvoie un résultat de type Future.

• invokeAny() accepte un ensemble de tâches à exécuter et renvoie le résultat de l'exécution réussie d'une tâche.

• invokeAll() accepte une collection de tâches à exécuter et renvoie le résultat de toutes les tâches sous la forme d'une liste d'objets de type Future.

• shutdown() il n'arrête pas immédiatement le service exécuteur mais n'accepte pas de nouvelles tâches. Une fois toutes les tâches en cours terminées, le service exécuteur est arrêté.

• shutdownNow() il essaie d'arrêter le service exécuteur immédiatement, mais il ne garantit pas que toutes les tâches en cours seront arrêtées en même temps.

• awaitTermination (long timeout, unité TimeUnit) bloque/attend que toutes les tâches soient terminées, que le délai d'attente se produise ou que le thread en cours soit interrompu, selon la première éventualité. Le fil de discussion actuel sera bloqué.

Types de services d'exécution

• FixedThreadPool Il crée un pool de threads de taille fixe avec un nombre spécifié de threads. Les tâches soumises sont exécutées simultanément. S'il n'y a aucune tâche, les threads seront inactifs jusqu'à ce que la tâche soit arrivée. Si les threads sont occupés, les tâches seront ajoutées à la file d'attente.

ExecutorService fixedThreadPool = Executors.newScheduledThreadPool(5);
Future<String> submit = fixedThreadPool.submit(() -> {
    System.out.println("Task executed by " + Thread.currentThread().getName());
    return Thread.currentThread().getName();
});
fixedThreadPool.shutdown();

• CachedThreadPool Crée un pool de threads et ajuste automatiquement le nombre de threads requis dans le pool en fonction de la charge de travail. Si le thread est inactif pendant plus de 60 secondes, il sera terminé. Cela fonctionne bien pour les charges dynamiques. Comme les threads seront supprimés après l'expiration du délai d'inactivité, les ressources sont mieux utilisées ici.

ExecutorService fixedThreadPool = Executors.newCachedThreadPool();
Future<String> submit = fixedThreadPool.submit(() -> {
    System.out.println("Task executed by " + Thread.currentThread().getName());
    return Thread.currentThread().getName();
});
fixedThreadPool.shutdown();

• SingleThreadExecutor Crée un seul thread et les tâches sont exécutées séquentiellement. Il n’y a pas de traitement parallèle ici.

ExecutorService fixedThreadPool = Executors.newSingleThreadExecutor();
Future<String> submit = fixedThreadPool.submit(() -> {
    System.out.println("Task executed by " + Thread.currentThread().getName());
    return Thread.currentThread().getName();
});
fixedThreadPool.shutdown()

• ScheduledThreadPool/ScheduledExecutor Il crée un pool de threads ou de trheads qui aura la capacité d'exécuter les tâches à intervalles réguliers ou de s'exécuter après un certain délai.

ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor(); // Single-threaded scheduler
ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(5); // Multi-threaded scheduler

scheduler.schedule(task, 10, TimeUnit.SECONDS); // Schedule task to run after 10 seconds.

scheduler.scheduleAtFixedRate(task, 5, 10, TimeUnit.SECONDS);
    //It schedules a task to run every 10 seconds with an initial delay of 5 seconds.
scheduler.scheduleWithFixedDelay(task, 5, 10, TimeUnit.SECONDS);
   //It schedules a task to run with a fixed delay of 10 seconds between the end of one execution and the start of the next, with an initial delay of 5 seconds.
scheduler.schedule(() -> scheduler.shutdown(), 20, TimeUnit.SECONDS);
   //It schedules a shutdown of the scheduler after 20 seconds to stop the example.

Soumission de tâches à ExecutorService
Les tâches peuvent être soumises à ExecutorService à l'aide des méthodesexecute() et submit(). La méthodeexecute() est utilisée pour les tâches Runnable, tandis que submit() peut gérer à la fois les tâches Runnable et Callable."

 executor.execute(new RunnableTask()); //fire-and-forgot
 executor.submit(new CallableTask()); //returns the status of task

Arrêter ExecutorService
Il est important d'arrêter ExecutorService pour libérer des ressources. Vous pouvez le faire en utilisant les méthodes shutdown() et shutdownNow().

executor.shutdown(); // Initiates an orderly shutdown"
executor.shutdownNow(); // Attempts to stop all actively executing tasks.
executor.awaitTermination(long timeout, TimeUnit unit); //blocks the thread until all tasks are completed or timeout occurs or current thread is interrupted, whichever happens first. Returns `true `is tasks completed, otherwise `false`.

Approche recommandée pour l'arrêt

executor.shutdown();
try {
    // Wait for tasks to complete or timeout
    if (!executor.awaitTermination(120, TimeUnit.SECONDS)) {
        // If the timeout occurs, force shutdown
        executor.shutdownNow();      
    }
} catch (InterruptedException ex) {
    executor.shutdownNow();
    Thread.currentThread().interrupt();
}

À propos de Runnable

• Runnable est une interface et représente une tâche qui peut être exécutée par des threads.
• Nous pouvons exécuter des tâches Runnable en utilisant le service Threads ou Executor.
• Runnable a la méthode run() et ne renvoie aucune donnée.
• Nous ne pouvons pas lancer d'exception vérifiée.

À propos de Callable

• Il est introduit en 1.5
• Il a la méthode call() et renvoie le type V.
• Il contient une exception qui signifie que nous pouvons lancer une exception vérifiée.

À propos de l'avenir

• Il représente un résultat futur de toute tâche.
• Le résultat apparaîtra éventuellement dans le futur une fois le traitement de la demande terminé.
• boolean isDone() Renvoie l'état du traitement de la demande. Vrai si complété sinon faux.
• boolean Cancel(boolean mayInterruptIfRunning) Annule la tâche soumise. si nous transmettons mayInterruptIfRunning comme false, cela n'annulera pas la tâche déjà démarrée.
• boolean isCancelled() renvoie la tâche annulée ou non.
• V get() renvoie le résultat de la tâche. Bloque le fil si la tâche n'est pas terminée.
• V get(long timeout, unité TimeUnit) Attend si nécessaire au maximum le temps imparti pour que le calcul se termine, puis récupère son résultat. TimeoutException sera levée après le temps spécifié si le calcul n'est pas terminé.

Bon codage et apprentissage !!!

Veuillez laisser un commentaire si vous avez des questions.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!