Exécuable, callable, futur, FutureTask, ExecutorService, Expetor, Excuteurs et ThreadPoolExcetor en Java résume ces mots clés et leur utilisation.
Classez d'abord:
Exécuable, appelant
Future, Futuretask
EMECTROCORSERVICE, EXCETOR, EXCUTOR, THELETPOOLEXCETOR
1. À propos de ranable et appelable
Tout d'abord, il existe trois façons de créer des fils en Java:
Avantages et inconvénients de trois implémentations:
En raison du thread hérité, d'autres classes ne peuvent pas être héritées et le thread actuel peut être obtenu.
Implémentez l'interface exécutable, pas de valeur de retour, obtenez le thread thread actuel.CurrentThread ()
Implémentez l'interface callable, vous pouvez obtenir la valeur de retour via future.get () et obtenir le thread thread actuel.currentThread ()
Thread hérité, deux étapes:
class DemothRead étend Thread {@Override public void run () {super.run (); // Effectuer une opération chronophage ...}} demothread t = new DemothRead (); t.Start ();Pour implémenter à l'exécution, utilisez généralement comme suit:
nouveau thread (new Runnable () {@Override public void run () {// faire quelque chose}}). start ();Pour simplicité.
Il est assez difficile d'obtenir les résultats de l'exécution du thread dans les deux méthodes ci-dessus et ne peut pas être obtenue directement. JDK1.5 ajoute la méthode callable, callable Call () pour retourner les valeurs et lancer des exceptions. Calable peut renvoyer un futur objet chargé des résultats de calcul.
Code source appelable:
Interface publique Callable <v> {v Call () lève une exception;}Utilisation de base de Callable:
FutureTask <Integer> FutureTask = new FutureTask <Integer> (New Callable <Integer> () {@Override public Integer Call () lève une exception {// faire quelque chose de retour null;}}); thread thread = new Thread (FutureTask); Thread.Start (); INTER Result = FutureTask.get ();L'exécution de la tâche callable peut obtenir un futur objet et obtenir la valeur de retour exécutée par le thread via la méthode GET () d'avenir. Alors ... futur,
Quelle est la différence entre Futuretask et comment l'utiliser?
-> Next ()
2. À propos de l'avenir et du futurask
Afin d'obtenir les résultats d'exécution du fil, FutureTask de Future a été introduit. Alors, quelle est leur relation et comment l'utiliser?
La classe future est située sous le package java.util.concurrent, qui est une interface:
Interface publique Future <v> {booléen annuler (booléen MayInterrupfrunning); Boolean Iscancelled (); Boolean Isdone (); V get () lève InterruptedException, ExecutionException; V Get (temps de temps long, unité TimeUnit) lance InterruptedException, ExecutionException, TimeoutException;}Future définit 5 méthodes:
1) booléen annule (booléen MayInterrupfrunning): tentez d'annuler l'exécution de cette tâche. Cette tentative échouera si la tâche est terminée, ou a été annulée, ou ne peut pas être annulée pour une autre raison. Lorsque Cancel () est appelé, si l'appel est réussi et que la tâche n'a pas été démarrée, la tâche ne s'exécutera jamais. Si la tâche a été démarrée, le paramètre MayInterrupfrunning détermine si le thread qui exécute la tâche doit être interrompu d'une manière qui tente d'arrêter la tâche. Une fois cette méthode renvoyée, les appels ultérieurs à Isdone () renvoient toujours vrai. Si cette méthode renvoie true, les appels ultérieurs à Iscancelled () rendront toujours vrai.
2) Boolean isCancelled (): Retour True si la tâche est annulée avant la fin de sa fin.
3) Boolean Isdone (): Retour True si la tâche est terminée. Cela peut être fait en raison d'une terminaison, d'une exception ou d'une annulation normale, dans tous ces cas, cette méthode reviendra vrai.
4) v get () lance InterruptedException, EXECUTUTIONException: si nécessaire, attendez que le calcul soit terminé, puis obtenez son résultat.
5) v Get (temps d'attente à longue durée, unité TimeUnit) lève InterruptedException, ExecutionException, TimeoutException: si nécessaire, attendez tout au plus après le temps donné pour compléter le calcul et obtenir le résultat (si le résultat est disponible).
En général, Future fournit trois fonctions:
Déterminer si la tâche est terminée;
Capacité à interrompre les tâches;
Capable d'obtenir des résultats d'exécution des tâches.
Points clés:
RunnableFuture hérite de l'interface Runnable et de l'interface future, tandis que FutureTask implémente l'interface RunnableFuture.
Implémentation de FutureTask:
classe publique FutureTask <v> implémente RunnableFuture <v>
Implémentation de l'interface RunnableFuture:
Interface publique RunnableFuture <v> étend Runnable, Future <v> {void run ();}FutureTask est une classe d'implémentation unique de l'interface future.
En plus d'emballer FutureTask avec du fil, il existe une autre façon de l'utiliser:
ExecutorService exécutor = exécutor.NewCachedThreadpool (); FutureTask <Integer> FutureTask = new FutureTask <Integer> (New Callable <Integer> () {@Override public Integer Call () lance une exception {// Do quelque chose null;}}); Executor.Submitte (FutureTask); Integer Résultat = Furtask.get; Le cadre de l'exécuteur est utilisé ici.
-> Next ();
3. À propos de l'exécuteur ExecutorService, Expetor, Excuteurs, ThreadpoolExcetor
Le cadre de l'exécuteur a été introduit dans Java 5. Le cadre de l'exécuteur est un cadre qui exécute des tâches asynchrones basées sur un ensemble d'appels de stratégie, de planification, d'exécution et de contrôle.
Avant de parler du cadre de l'exécuteur, nous devons introduire un nouveau concept - ThreadPoolExecutor:
Public ThreadPoolExecutor (IntcorepoolSize, int maximumpoolSize, long keepalivetime, timeunit unit, blocingqueue <runnable> workqueue, threadfactory threadfactory, rejectEdExecutionHandler Handler)
ThreadPoolExecutor est l'implémentation sous-jacente de la classe des exécuteurs.
Dans la documentation de l'aide JDK, il y a un passage:
"Il est fortement recommandé que les programmeurs utilisent les exécuteurs des méthodes d'usine d'exécuteurs les plus pratiques.
Alors, que sont les EMCRORORSERCICE, EXCETOR et EXCUTOR?
Excetor est une interface centrale au niveau abstrait:
Exécuteur de l'interface publique {void execute (Commande Runnable);}L'interface ExecutorService étend l'interface de l'exécuteur et fournit des méthodes telles que le retour d'objets futurs, la terminaison, la fermeture des pools de threads, etc.
Public Interface ExecutorService étend l'exécuteur {void shutdown (); <T> Future <T> soumettre (tâche callable <T>); <T> Future <T> Soumider (tâche Runnable, T Result); <T> Liste <Future <T>> InVokeALL (Collection <? Étend des tâches callables <T>>, Long Timeout, TimeUnit Unit) lance InterruptedException;}Les exécuteurs sont une classe d'outils similaire aux collections. Fournit des méthodes d'usine pour créer différents types de pools de threads, tels que FixedTreadpool ou CacheThreadPool.
Exécuteurs de classe publique {public static exécutorService newFixEdThreadpool (int nThreads) {return new ThreadPoolExeCutor (nthreads, nthreads, 0l, timeunit.milliseconds, new LinkedBlockerEue <Runnable> ()); } public static ExecutorService newcachedThreadpool () {return new ThreadPoolExecutor (0, Integer.max_value, 60L, timeunit.seconds, new synchronousqueue <runnable> ()); }}Ce qui précède est une compilation de mots clés multithreads Java, donc il ne sera pas désordonné.
Ce qui précède est l'implémentation du tri des mots clés multi-thread dans Java introduit par l'éditeur. J'espère que ce sera utile à tout le monde. Si vous avez des questions, veuillez me laisser un message et l'éditeur répondra à tout le monde à temps. Merci beaucoup pour votre soutien au site Web Wulin.com!