Programmation parallèle à l'aide d'appelable et d'avenir
La façon la plus courante d'effectuer une programmation parallèle dans Java est de hériter de la classe de threads ou d'implémenter l'interface Runnable. L'inconvénient de ces deux méthodes est que le résultat de l'exécution ne peut pas être obtenu directement une fois la tâche terminée, et elle doit être communiquée par des variables ou des internes partagées, qui ne sont pas pratiqués à utiliser.
À partir de Java 1.5, des interfaces appelables et futures sont fournies. En les utilisant, vous pouvez obtenir le résultat d'exécution après l'exécution de la tâche.
Apprenons à utiliser Callable, Future et FutureTask.
Interface appelable
L'interface appelée est située dans le package java.util.concurrent. Il s'agit d'une interface générique qui ne déclare qu'une méthode d'appel ():
Interface publique callable <T> {t Call () lève une exception;}Généralement, il est utilisé en conjonction avec l'interface ExecutorService. Plusieurs méthodes de soumission surchargées sont déclarées dans l'interface ExecutorService:
<T> Future <T> soumettre (tâche callable <T>); <T> Future <T> soumettre (tâche Runnable, T Result); Future <?> Soumider (tâche Runnable);
Le type de paramètre dans la première méthode de soumission est appelable, et les deux autres ne sont pas couverts par cet article pour le moment.
Future et Futuretask
La classe d'implémentation de l'interface future peut effectuer des opérations telles que l'annulation, l'interrogation et l'obtention de résultats sur des tâches exécutables ou appelables.
L'interface future est également située sous le package java.util.concurrent:
Interface publique Future <T> {/ ** * Annuler la tâche * @ Param MayInterrupfrunning * Permet-il d'annuler des tâches qui sont exécutées mais non terminées? Si TRUE est défini, cela signifie que la tâche du processus peut être annulée * Si la tâche est en cours d'exécution, il renvoie True * Si la tâche n'a pas encore été exécutée, il renvoie True si MayInterrupTifrunning est vrai ou faux * / booléen Annuler (booléen peut interruption); / ** * La tâche est-elle annulée avec succès? S'il est annulé avec succès avant la fin de la tâche normalement, il renvoie True * / boolean isCancelled (); / ** * La tâche est-elle terminée * / booléen isdone (); / ** * Obtenez le résultat d'exécution via le blocage * / t get () lance InterruptedException, EXECUTUTIONException; / ** * Obtenez le résultat d'exécution par le blocage. Si aucun retour n'est renvoyé dans le temps spécifié, Retour Null * / t Get (temps mort, unité TimeUnit) lève InterruptedException, ExecutionException, TimeEutException;}Pour résumer, Future fournit trois fonctions:
Déterminez si la tâche est terminée et peut interrompre la tâche et obtenir le résultat de l'exécution de la tâche
JDK nous fournit une future classe d'implémentation d'interface FutureTask, qui a les deux constructeurs suivants.
public FutureTask (callable <t> callable) {} public FutureTask (Runnable Runnable, t Result) {} Exemple de code
Utilisation de Future, futur appelant
import java.util.concurrent. *; public class test {public static void main (String [] args) {exécutorService exécutorService = exécutor.newcachedThreadpool (); Tâche tâche = new tâche (); Future <Integer> futur = exécutorService.Submit (tâche); ExecutorService.shutdown (); System.out.println ("Le thread principal exécute la tâche ..."); essayez {thread.sleep (2000); } catch (InterruptedException ex) {ex.printStackTrace (); } essayez {System.out.println ("Tâche Result Résultat:" + futur.get ()); } catch (InterruptedException ex) {ex.printStackTrace (); } catch (ExecutionException ex) {ex.printStackTrace (); } System.out.println ("Toutes les tâches ont été exécutées"); }} La tâche de classe implémente callable <Integer> {@Override public Integer Call () lève une exception {System.out.println ("Child Thread exécute la tâche ..."); // La tâche de simulation prend du temps de temps. Sleep (5000); retour 1000; }}Résultats de l'exécution:
Le thread enfant exécute la tâche ... Le thread principal exécute la tâche ... Résultat de l'opération de tâche: 1000 Toutes les tâches ont été exécutées
Utilisez Callable, FutureTask
import java.util.concurrent. *; public class test {public static void main (String [] args) {exécutorService exécutorService = exécutor.newcachedThreadpool (); Tâche tâche = new tâche (); FutureTask <Integer> FutureTask = new FutureTask <Integer> (tâche); ExecutorService.Submit (FutureTask); ExecutorService.shutdown (); System.out.println ("Le thread principal exécute la tâche ..."); essayez {thread.sleep (2000); } catch (InterruptedException ex) {ex.printStackTrace (); } essayez {System.out.println ("Tâche Result Résultat:" + FutureTask.get ()); } catch (InterruptedException ex) {ex.printStackTrace (); } catch (ExecutionException ex) {ex.printStackTrace (); } System.out.println ("Toutes les tâches sont exécutées"); }} La tâche de classe implémente Calable <Integer> {@Override public Integer Call () lève l'exception {System.out.println ("Le thread enfant exécute la tâche ..."); // simulant la tâche prend Thread.Sleep (5000); retour 1000; }}Résultats de l'exécution:
Le thread enfant exécute la tâche ... Le thread principal exécute la tâche ... Résultat de l'opération de tâche: 1000 Toutes les tâches ont été exécutées
Résumer
Ce qui précède est tout le contenu de cet article sur l'utilisation d'appelable et d'avenir pour la programmation parallèle en Java. J'espère que ce sera utile à tout le monde. Les amis intéressés peuvent continuer à se référer à d'autres sujets connexes sur ce site. S'il y a des lacunes, veuillez laisser un message pour le signaler. Merci vos amis pour votre soutien pour ce site!