Comment implémenter une interface appelable en Java

Cet article vous fournira une connaissance détaillée et complète de la façon d'implémenter Callable Interface en Java avec des exemples.

Les programmes multithreading Java témoignent de l'utilisation de Appelable et futur. Grâce à la connaissance préalable des threads et du multi-threading, les lecteurs seront mieux à même de saisir la discussion de cet article. Comme j'expliquerai l'interface appelable en Java dans cet article.

Récapitulatif sur les discussions

Cependant, permettez-moi de vous présenter brièvement le concept de threads. Un thread est un chemin d'exécution distinct, au cas où vous auriez besoin d'effectuer une tâche répétitive, le travail peut être divisé en plusieurs tâches et les affecter à des threads. Multi-threadingn'est rien d'autre que l'affectation de plusieurs threads pour exécuter différentes tâches en parallèle pour obtenir le résultat rapidement.





Qu'est-ce que l'interface appelable en Java

Pour Java 5, la classe «java.util.concurrent» a été introduite. Cette interface appelable a été introduite via le package d'accès concurrentiel qui ressemblait à l'interface Runnable. Il peut également renvoyer n'importe quel objet et peut lancer une exception. Une interface Java Callable utilise des génériques, permettant ainsi de renvoyer tout type d'objet. Le Framework Executor fournit une méthode submit () pour exécuter des implémentations Callable dans un pool de threads. En réalité, le Java Executor Framework adhère aux modèles WorkerThread.

java-interfaceDans un pool de threads, les utilisateurs peuvent lancer des threads à l'aide de la méthode Executors.newFixedThreadPool (10) et lui soumettre en conséquence une tâche. Un exécutable agit comme la cible d'un thread et une méthode publique void run () est obligatoirement implémentée pour définir la tâche. Cela sera exécuté par les threads du pool de threads. En fonction de la disponibilité des threads dans le pool, Executor Framework attribue le travail (cible exécutable) aux threads.Si tous les threads sont en cours d'utilisation, la tâche doit être bloquée. Une fois que le thread a terminé une tâche, il retourne au pool en tant que thread disponible, prêt à accepter les tâches futures. Callable est similaire à Runnable et peut renvoyer n'importe quel type d'objet lorsque nous voulons obtenir un résultat ou un statut de la tâche.



Retour de l'interface appelable

Java Callable renvoie java.util.concurrent. Java Future propose une méthode cancel () pour éliminer la tâche appelable associée. Il s'agit d'une version surchargée de la méthode get (), où l'on peut spécifier un certain temps pour attendre le résultat. Il est utile d'éviter un thread en cours, qui peut être bloqué pendant une période plus longue. N'oubliez pas que la méthode get est une méthode synchrone et que jusqu'à ce que l'appelable termine sa tâche et renvoie une valeur, il devra attendre un appelable.

Il existe également des méthodes «isDone ()» et «isCancelled ()» pour récupérer l'état actuel d'une tâche appelable associée. Prenons l'exemple où une somme de tous les nombres de un à 100 doit être trouvée. Nous pouvons boucler 1 à 100 séquentiellement et les ajouter enfin. Une autre possibilité est de diviser et de conquérir. Dans cette méthode, nous pouvons regrouper les nombres de manière à ce que chaque groupe ait exactement deux éléments. Enfin, nous pouvons affecter ce groupe à un pool de threads. Par conséquent, chaque thread retourne une somme partielle en parallèle, puis collecte ces sommes partielles et les ajoute pour obtenir la somme entière.



terminer un programme en java

Caractéristiques de Callable et Future Class

  • La classe appelable est une interface de type SAM et peut donc être implémentée dans l'expression lambda.

    quelles sont les instances en java
  • La classe appelable n'a qu'une seule méthode «call ()» qui contient tout le code nécessaire pour s'exécuter de manière asynchrone.

  • Dans un environnement d'interface exécutable, il n'y avait aucune possibilité de renvoyer le résultat du calcul ou de lancer une exception vérifiée. Alors que Callable renvoie une valeur et lève une exception vérifiée est disponible.

  • La méthode Get () de la classe Future peut être utilisée pour récupérer les résultats une fois le calcul terminé. Les utilisateurs peuvent également vérifier si le calcul est terminé ou non en utilisant la méthode done ().

  • L'annulation du calcul à l'aide de la méthode future.cancel () est également une aubaine dans certaines applications.

  • Get () est appelé un appel bloquant et il continue à se bloquer jusqu'à ce que le calcul soit terminé.

Comparaison des classes appelables et exécutables

Appelable Runnable
Cela fait partie du ' java.util.concurrent ' package depuis Java 1.5Il fait partie du package java.lang depuis Java 1.0
Une interface paramétrée, telle que CallableUne interface non paramétrée
Capable de lancer une exception vérifiéeIl ne peut pas lever d'exception vérifiée
Il contient une seule méthode, call (), qui renvoie le type V, c'est le même que le paramètre d'interface défini «Type»Ici, il contient une seule méthode, appelée run (), qui renvoie void

Vous trouverez ci-dessous un exemple simple de classe appelable Java implémentée dans laquelle le code renvoie le nom du thread spécifique, qui exécute la tâche après une seconde. Ici, nous utilisons le framework d'extraction pour exécuter 100 tâches en parallèle avec Java Future au résultat des tâches soumises. Le premier extrait de code est la sortie et le ci-dessous représente le code.

package com.journaldev.threads import java.util.ArrayList import java.util.Date import java.util.List import java.util.concurrent.Callable import java.util.concurrent.ExecutionException import java.util.concurrent.ExecutorService import java .util.concurrent.Executors import java.util.concurrent.Future classe publique MyCallable implémente Callable {@Override public String call () throws Exception {Thread.sleep (1000) // retourne le nom du thread exécutant cette tâche appelable return Thread.currentThread () .getName ()} public static void main (String args []) {// Récupère ExecutorService de la classe utilitaire Executors, la taille du pool de threads est de 10 ExecutorService executor = Executors.newFixedThreadPool (10) // crée une liste pour contenir l'avenir objet associé à la liste appelablelist = new ArrayList() // Créer une instance MyCallable Callable callable = new MyCallable () for (int i = 0 i<100 i++){ //submit Callable tasks to be executed by thread pool Future future = executor.submit(callable) //add Future to the list, we can get return value using Future list.add(future) } for(Future fut : list){ try { //print the return value of Future, notice the output delay in console // because Future.get() waits for task to get completed System.out.println(new Date()+ '::'+fut.get()) } catch (InterruptedException | ExecutionException e) { e.printStackTrace() } } //shut down the executor service now executor.shutdown() } } 

Arrêt des services de l'exécuteur

L'aspect crucial et important qui manque à de nombreux développeurs est la fermeture d'ExecutorService. L'ExecutorService est vital et est créé avec des éléments de thread supplémentaires. Gardez à l'esprit que la JVM ne s'arrête que lorsque tous les threads non démon sont arrêtés. Ainsi, la simple fermeture du service exécuteur empêche l'arrêt de la machine virtuelle Java.

Afin de dire au service exécuteur qu'il n'est pas nécessaire que les threads soient exécutés, nous devons arrêter le service.

Il existe trois façons d'appeler l'arrêt:

  • arrêt nul () - Cela déclenche un arrêt ordonné dans lequel les tâches précédemment soumises sont exécutées, mais aucune nouvelle tâche n'est acceptée.
  • Liste shutdownNow () - Il tente d'arrêter toutes les tâches en cours d'exécution, interrompt le traitement des tâches en attente et renvoie également une liste des tâches en attente d'exécution.
  • void waitTermination () - Cela continue à se bloquer jusqu'à ce que toutes les tâches aient terminé leur exécution après une demande d'arrêt ou jusqu'à ce que le délai expire. Il se bloque également lorsque le thread actuel est interrompu. Tout dépend de la tâche qui vient en premier.

Avec cela, nous arrivons à la fin de l'article Callable Interface in Java. J'espère que vous avez une compréhension de Future and Callable Interface en Java.

comment utiliser la puissance en java

Vérifiez par Edureka, une entreprise d'apprentissage en ligne de confiance avec un réseau de plus de 250 000 apprenants satisfaits répartis dans le monde entier. Le cours de formation et de certification Java J2EE et SOA d'Edureka est conçu pour les étudiants et les professionnels qui souhaitent devenir développeur Java.

Vous avez une question pour nous? Veuillez le mentionner dans la section commentaires de ce blog «Callable Interface in Java» et nous vous répondrons dans les plus brefs délais.