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 taches en programmation simultanée. Il prend en charge les taches exécutables et appelables. Il renvoie Future pour le statut de la tache. Vous trouverez ci-dessous les méthodes les plus fréquemment utilisées.

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

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

• invokeAll() accepte une collection de taches à exécuter et renvoie le résultat de toutes les taches 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 taches. Une fois toutes les taches 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 taches en cours seront arrêtées en même temps.

• awaitTermination (long timeout, unité TimeUnit) bloque/attend que toutes les taches 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 taches soumises sont exécutées simultanément. S'il n'y a aucune tache, les threads seront inactifs jusqu'à ce que la tache soit arrivée. Si les threads sont occupés, les taches 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 taches 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 taches à 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 taches à ExecutorService
Les taches peuvent être soumises à ExecutorService à l'aide des méthodesexecute() et submit(). La méthodeexecute() est utilisée pour les taches Runnable, tandis que submit() peut gérer à la fois les taches 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 tache qui peut être exécutée par des threads.
• Nous pouvons exécuter des taches 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 tache.
• 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 tache soumise. si nous transmettons mayInterruptIfRunning comme false, cela n'annulera pas la tache déjà démarrée.
• boolean isCancelled() renvoie la tache annulée ou non.
• V get() renvoie le résultat de la tache. Bloque le fil si la tache 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!