1. Exécuteurs
La classe des exécuteurs peut être considérée comme une "classe d'outils". Citant l'introduction dans l'API JDK1.6:
Méthodes d'usine et pratiques de l'exécuteur, des classes ExecutorService, ScheduleDexeCutOrService, ThreadFactory et Callable définies dans ce package. Cette classe prend en charge diverses méthodes:
(1) Créez et renvoyez la méthode de définition de l'exécution de la Service avec des chaînes de configuration couramment utilisées.
(2) Créez et renvoyez la méthode de définition de la planification de réserve de planification avec des chaînes de configuration couramment utilisées.
(3) Créer et renvoyer la méthode ExecutorService "enveloppée", qui désactive la reconfiguration en rendant les méthodes spécifiques à l'implémentation inaccessibles.
(4) Créer et renvoyer une méthode de ThreadFactory, qui peut définir le thread nouvellement créé sur un état connu.
(5) Créer et renvoyer une méthode appelée non fermée, afin qu'elle puisse être utilisée dans les méthodes d'exécution qui nécessitent un appelable.
Grâce à cette classe, vous pouvez obtenir plusieurs instances de pools de threads, tels que l'appel NewsingLetHreAdExEcutor () pour obtenir un seul thread ExecutorService, appeler newFixEdThreadPool () pour obtenir un service d'exécution d'exécution d'un pool de fils de taille fixe, etc. La chose la plus simple est de l'utiliser pour exécuter des objets exécutables, ou vous pouvez exécuter certains objets qui implémentent callable <T>. Il n'y a pas de valeur de retour en utilisant la méthode start () de thread. Si la méthode exécutée par le thread a une valeur de retour, il serait préférable d'utiliser ExecutorService. Vous pouvez choisir Soumider (), inVokeAll () ou InVokeany () et sélectionner la méthode appropriée en fonction de la situation spécifique.
Certaines des méthodes fournies dans cette classe sont:
1.1 Public Static ExecutorService NewCachedThreadpool ()
Créez un pool de fils qui crée de nouveaux threads au besoin, mais les réutilisera lorsque des threads précédemment construits sont disponibles. Ces pools de threads améliorent généralement les performances du programme pour les programmes qui effectuent de nombreuses tâches asynchrones à court terme.
1.2 Public Static ExecutorService NewFixEdThreadpool (int nThreads)
Créez un pool de threads avec un nombre fixe de threads réutilisables pour exécuter ces threads dans une file d'attente non liée partagée.
1.3 Public Static ExecutorService NewsingLetHreAdExecutor ()
Créez un exécuteur testamentaire qui utilise un seul thread de travailleur pour exécuter le thread dans une file d'attente illimitée.
Les trois méthodes peuvent être utilisées avec des instances d'interface threadfactory. Et renvoyez une instance de l'interface ExecutorService.
2. Interface threadfactory
Créez de nouveaux objets de thread selon les besoins. L'utilisation d'usines de thread ne nécessite plus d'écriture manuelle de nouveaux appels de thread, permettant aux applications d'utiliser des sous-classes de threads spéciales, des propriétés, etc.
L'implémentation la plus simple de cette interface est:
classe SimpleThreadFactory implémente ThreadFactory {public thread newthread (runnable r) {return new Thread (r); }} 3. Interface ExecutorService
Cette interface fournit une méthode pour gérer la terminaison.
4. Créer un thread de démarrage de pool de thread standard
4.1 Fournir un thread simple qui implémente l'interface runnable
Mythread.java
package com.zj.concurrency.executors; La classe publique Mythread implémente Runnable {private int count = 1, numéro; public mythread (int num) {nombre = num; System.out.println ("Create Thread-" + numéro); } public void run () {while (true) {System.out.println ("thread-" + numéro + "run" + count + "time (s)"); if (++ count == 3) return; }}} Ce fil imprimera les informations de création et d'exécution correspondantes.
4.2 Démarrer le thread à l'aide de CachedThreadpool
Cachethreadpool.java
package com.zj.concurrency.executors; import java.util.concurrent.executorService; import java.util.concurrent.execUtors; classe publique CachedThreadpool {public static void main (String [] args) {EMMIRCORORSERVICE EXEC = EMICATORS.NEWCACHEDTHREADPOOL (); pour (int i = 0; i <5; i ++) exec.execute (new Mythread (i)); exec.shutdown (); }} résultat:
Créer Thread-0Create Thread-1Create Thread-2Create Thread-3Thread-0 Exécutez 1 fois (S) Thread-0 Exécutez 2 fois (S) Thread-1 Exécutez 1 fois (S) Thread-1 Exécuter 2 fois (S) Thread-2 Exécutez 1 fois (S) Thread-2 Exécutez 2 Time (S) Créer Thread-4Thread-4 Exécuter 1 fois (S) Thread-4 Exécuter 2 Time (S) Thread-3 Run 1 Time (s) Thread-3 Run 2 Temps (S)
4.3 Démarrer le thread à l'aide de FixedTheredpool
FixeThreadpool.javapackage com.zj.concurrency.execcutors; import java.util.concurrent.executorService; import java.util.concurrent.executors; classe publique fixeThreadpool {public static void main (String [] args) {exécutorService exec = exécutor.newFixEdThreadpool (2); pour (int i = 0; i <5; i ++) exec.execute (new Mythread (i)); exec.shutdown (); }} résultat:
Créer Thread-0create Thread-1Create Thread-2Create Thread-3Create Thread-4Thread-0 Exécutez 1 fois (S) Thread-0 Exécutez 2 fois (S) Thread-2 Exécutez 1 fois (S) Thread-2 Exécutez 2 fois (S) Thread-3 Exécutez 1 fois (S) Thread-3-3 2 Time (S) Thread-4 Run 1 Temps (S) Thread-4 Exécuter 2 Time (S) Thread-1 Exécution 1 Temps (S) Fil
4.4 Démarrer le thread à l'aide de singlethreadexecutor
Singlethreadexecutor.java
package com.zj.concurrency.executors; import java.util.concurrent.executorService; import java.util.concurrent.execUtors; classe publique SingleThreAdExECUTOR {public static void main (String [] args) {exécutorService exec = exécutors.newSingLethreAdExecutor (); pour (int i = 0; i <5; i ++) exec.execute (new Mythread (i)); exec.shutdown (); }} résultat:
Create Thread-0Create Thread-1Create Thread-2Create Thread-3Create Thread-4Thread-0 run 1 time(s)Thread-0 run 2 time(s)Thread-1 run 1 time(s)Thread-1 run 2 time(s)Thread-2 run 1 time(s)Thread-2 run 2 time(s)Thread-3 run 1 time(s)Thread-3 run 2 time(s)Thread-4 run 1 time(s)Thread-4 run 2 time(s)
5. Coopérer avec l'utilisation de l'interface ThreadFactory
Nous essayons d'ajouter des paramètres de démon et d'attribut de priorité au fil.
5.1 Définir les propriétés du thread d'arrière-plan
Daemthreadfactory.java
package com.zj.concurrency.execcutors.factory; import java.util.concurrent.threadfactory; classe publique DaemThreadFactory implémente ThreadFactory {public thread newthread (runnable r) {Thread t = new Thread (r); t.setDaemon (true); retour t; }}
5.2 Définir les attributs de priorité
Maxprioritythreadfactory.java
package com.zj.concurrency.execcutors.factory; import java.util.concurrent.threadfactory; classe publique MaxPriorityThreadFactory implémente ThreadFactory {public thread newthread (runnable r) {thread t = new Thread (r); t.setPriority (thread.max_priority); retour t; }} Priorité minimaleMinpriorityThreadfactory.java
package com.zj.concurrency.execcutors.factory; import java.util.concurrent.threadfactory; classe publique MinPriorityThreadFactory implémente ThreadFactory {public thread newthread (runnable r) {Thread t = new Thread (r); t.setPriority (thread.min_priority); retour t; }}
5.3 Démarrer le thread avec les paramètres d'attribut
Execfromfactory.java
package com.zj.concurrency.execcutors; import java.util.concurrent.execcutorservice; import java.util.concurrent.execcutors; import com.zj.concurrency.execcutors.factory.daemonthreadfactory; import com.zj.concurrency.execcutors.factory.maxpriorrityereadareadfacture; com.zj.concurrency.executors.factory.MinpriorityThreadFactory; classe publique ExecFromFactory {public static void main (String [] args) lève une exception {ExecutorService defaultExec = exécutors.newcachedThreadPool (); ExecutorService daemonexec = exécuteurs .NewCachedThreadPool (new DaemonThreadFactory ()); ExecutorService maxpriorityExec = exécuteurs .NewCachedThreadPool (new maxpriorityThreadFactory ()); ExecutorService minpriorityExec = exécuteurs .NewCachedThreadPool (new MinPriorityThreadFactory ()); pour (int i = 0; i <10; i ++) daemonexec.execute (new Mythread (i)); pour (int i = 10; i <20; i ++) if (i == 10) maxpriorityExec.Execute (new Mythread (i)); else if (i == 11) minpriorityExec.excute (new Mythread (i)); else defaultExec.Execute (new Mythread (i)); }} résultat:
Create Thread-0Create Thread-1Create Thread-2Create Thread-3Thread-0 run 1 time(s)Thread-0 run 2 time(s)Thread-1 run 1 time(s)Thread-1 run 2 time(s)Thread-2 run 1 time(s)Thread-2 run 2 time(s)Create Thread-4Thread-4 run 1 time(s)Thread-4 run 2 time(s)Create Thread-5Thread-5 run 1 time(s)Thread-5 run 2 time(s)Create Thread-6Create Thread-7Thread-7 run 1 time(s)Thread-7 run 2 time(s)Create Thread-8Thread-8 run 1 time(s)Thread-8 run 2 time(s)Create Thread-9Create Thread-10Thread-10 run 1 time(s)Thread-10 run 2 time(s)Create Thread-11Thread-9 run 1 time(s)Thread-9 run 2 time(s)Thread-6 run 1 time(s)Thread-6 run 2 Temps (s) Thread-3 Exécutez 1 fois (S) Thread-3 Exécutez 2 fois (s) Créer Thread-12Create Thread-13Create Thread-14THREAD-12 Exécutez 1 fois (S) Thread-12 Exécuter 2 fois (S) Thread-13 Exécutez 1 fois (S) Thread-13 Run 2 Time (S) Créer Thread-15Thread-15 Run 1 Time (S) Thread-15 Run 2 Time (S) Créer Thread-16Thread-16 Run 1 Time (S) Thread-15 Run 2 Time (S) Temps (s) Créer Thread-17Create Thread-18Create Thread-19Thread-14 Exécutez 1 fois (S) Thread-14 Exécutez 2 fois (S) Thread-17 Exécuter 1 fois (S) Thread-17 Exécuter 2 fois (S) Thread-18 Exécuter 1 fois (S) Thread-18 Exécuter 2 fois (S) Thread-19 Exécuter 1 fois (S) Thread-19 Exécuter 2 Time (S) Thread-11 Run 1 Time (S) Thread-1 Exécuter 2 Temps (S) Thread-11 Fix