Analyse de quatre méthodes d'utilisation du pool de threads Java

Cet article analyse quatre utilisations de pool de fils Java pour votre référence. Le contenu spécifique est le suivant

1. Les inconvénients du nouveau fil

Exécutez-vous toujours un nouveau fil comme suit lors de l'exécution d'une tâche asynchrone?

 nouveau thread (new Runnable () {@Override public void run () {// TODO Méthode générée automatiquement Stub}}). start ();

Ensuite, vous aurez trop de retraits, les inconvénients du nouveau fil sont les suivants:

un. Les performances du nouveau fil sont pauvres à chaque fois.
né Les threads manquent de gestion unifiée, qui peut créer de nouveaux threads sans restrictions, se concurrencer les uns avec les autres et peut occuper trop de ressources système pour provoquer des accidents ou des ooms.
c. Manque de plus de fonctions, telles que l'exécution chronométrée, l'exécution périodique, l'interruption du thread.

Par rapport au nouveau fil, les avantages des quatre pools de threads fournis par Java sont:

un. Réutilisez les threads existants pour réduire les frais généraux de la création et de l'extinction d'objets, et bien performer.
né Il peut contrôler efficacement le nombre maximal de threads simultanés, améliorer le taux d'utilisation des ressources du système et éviter une concurrence excessive des ressources et éviter le blocage.
c. Fournit des fonctions telles que l'exécution chronométrée, l'exécution régulière, le threading unique, le contrôle des nombres simultanés, etc.

2. Pool de fil Java

Java fournit quatre types de pools de fil par le biais d'exécuteurs, à savoir:

NewCachedThreadpool crée une piscine de fil cacheable. Si la longueur du pool de filetage dépasse les besoins de traitement, il peut recycler flexiblement les threads inactifs. S'il n'y a pas de recyclage, créez un nouveau fil.
NewFixEdThreadPool crée un pool de threads de longueur fixe qui peut contrôler le nombre maximum de threads concurrencés, et les threads excédentaires attendront dans la file d'attente.
NewsCheDuleDThreadPool crée un pool de threads de longueur fixe qui prend en charge l'exécution de tâches chronométrée et périodique.
NewsingEthreAdExecutor crée un pool de threads unique, qui n'utilisera qu'un thread de travailleur unique pour exécuter des tâches, en veillant à ce que toutes les tâches soient exécutées dans l'ordre spécifié (FIFO, LIFO, priorité).
(1) NewCachedThreadpool:

Créez une piscine de threads cacheable. Si la longueur du pool de fils dépasse les besoins de traitement, vous pouvez recycler flexiblement les threads inactifs. S'il n'y a pas de recyclage, créez un nouveau fil. L'exemple de code est le suivant:

 ExecutorService cachedThreadpool = exécutor.NewCachedThreadPool (); pour (int i = 0; i <10; i ++) {final int index = i; essayez {thread.sleep (index * 1000); } catch (InterruptedException e) {e.printStackTrace (); } cachedThreadpool.Execute (new Runnable () {@OverRidePublic void run () {System.out.println (index);}});}

La piscine de fil est infinie. Lorsque la deuxième tâche est exécutée, la première tâche est terminée et le thread qui exécute la première tâche sera réutilisé sans créer un nouveau fil à chaque fois.

(2) NewFixEdThreadpool:

Créez un pool de threads de longueur fixe qui peut contrôler le nombre maximum de threads concurrencés, et les threads excédentaires attendront dans la file d'attente. L'exemple de code est le suivant:

 ExecutorService fixeThreadpool = exécutor.NewFixEdThreadPool (3); pour (int i = 0; i <10; i ++) {final int index = i; FixedThreadpool.Execute (new Runnable () {@OverRidePublic void run () {try {System.out.println (index); Thread.Sleep (2000);} Catch (InterruptedException e) {// TODO Auto-Generated Catch Block E.PrintStStackTrace ();}}});} Auto-Generated Catch Block

Étant donné que la taille du pool de threads est de 3, dormez 2 secondes après l'index de chaque tâche, donc 3 numéros sont imprimés toutes les deux secondes.

La taille d'un pool de threads de longueur fixe est mieux définie en fonction des ressources système. Tels que runtime.getRuntime (). DisponibleProcessors (). Veuillez vous référer à Preloaddatacache.

(3) NewscheduledThreadpool:

Créez un pool de threads de longueur fixe qui prend en charge l'exécution de la tâche temporisée et périodique. L'exemple de code pour l'exécution retardée est le suivant:

 ScheduleDExECUTORService scheduledThreadpool = exécuteurs.NewScheduLedThreadPool (5); ScheduledThreadpool.Schedule (new Runnable () {@OverRidePublic void run () {System.out.println ("Delay 3 secondes");}}, 3, timeunit.seconds);

Indique l'exécution de retard de 3 secondes.

L'exemple de code est exécuté régulièrement comme suit:

 ScheduledThreadpool.ScheDuleAtFixeDrate (new Runnable () {@OverRidePublic void run () {System.out.println ("Delay 1 secondes, et excuse toutes les 3 secondes");}}, 1, 3, timeunit.seconds);

Cela signifie que le retard est effectué toutes les 3 secondes après 1 seconde.

ScheduleDexecutorService est plus sûr et plus puissant que la minuterie

(4) NewsingLethreAdExecutor:

Créez un pool de threads unique, qui n'utilisera qu'un thread de travailleur unique pour exécuter des tâches, en s'assurant que toutes les tâches sont exécutées dans l'ordre spécifié (FIFO, LIFO, priorité). L'exemple de code est le suivant:

 EMECTROVERSERVICE SINGETHREADEXECUTOR = EXICGEMENTS.NEWSINGLETHREADEXECUTOR (); For (int i = 0; i <10; i ++) {final int index = i; singleThreAdExecutor.Execute (new Runnable () {@OverridePublic Void run () {trye System.out.println (index); (InterruptedException e) {// TODO Bloc de capture généré automatiquement E.PrintStackTrace ();}}});}

Les résultats sont sortis en séquence, ce qui équivaut à l'exécution de chaque tâche en séquence.

La plupart des programmes d'interface graphique actuels sont à thread unique. Les threads uniques dans Android peuvent être utilisés pour les opérations de base de données, les opérations de fichiers, l'installation par lots d'applications, la suppression par lots d'applications, etc., qui ne conviennent pas pour simultanément mais peuvent bloquer IO et affecter la réponse des threads d'interface utilisateur.

La fonction du pool de threads:

La fonction d'un pool de threads est de limiter le nombre de threads exécutés dans le système.
Selon l'environnement système, le nombre de threads peut être défini automatiquement ou manuellement pour obtenir le meilleur effet de fonctionnement; Moins de ressources système sont gaspillées et plus de congestion du système n'est pas élevée. Utilisez un pool de threads pour contrôler le nombre de threads, et d'autres threads attendent en ligne. Une fois une tâche exécutée, la première tâche est tirée de la file d'attente pour démarrer l'exécution. S'il n'y a pas de processus d'attente dans la file d'attente, cette ressource du pool de threads attend. Lorsqu'une nouvelle tâche doit être exécutée, s'il y a des threads de travail en attente dans le pool de threads, il peut commencer à fonctionner; Sinon, il entrera dans la file d'attente en attente.

Pourquoi utiliser la piscine de thread:

1. Réduit le nombre de fois les threads sont créés et détruits, et chaque fil de travail peut être réutilisé et peut effectuer plusieurs tâches.

2. Le nombre de threads de travail dans le pool de threads peut être ajusté en fonction de la capacité du système à empêcher le serveur d'être aspiré en raison d'une consommation excessive de mémoire (chaque thread nécessite environ 1 Mo de mémoire. Plus des threads sont ouverts, plus la mémoire consommée est grande et enfin le crash sera.

L'interface de niveau supérieur du pool de threads dans Java est exécuteur, mais à proprement parler, l'exécuteur exécuteur n'est pas un pool de threads, mais juste un outil pour exécuter des threads. L'interface de pool de threads réel est EMMICRORSERVICE.

Plusieurs catégories plus importantes:

EMECTROGROSSERVICE: une véritable interface de pool de threads.

ScheduleDexecutorService: il peut être similaire à Timer / Timetask, en résolvant des problèmes qui nécessitent des tâches répétées.

ThreadPoolExecutor: l'implémentation par défaut de ExecutorService.

ScheduledThreadPoolExecutor: une implémentation de classe de l'interface ScheduleDExECUtorService qui hérite de ThreadPoolExecutor, une implémentation de classe de planification de tâches périodique.

Il est assez compliqué de configurer un pool de threads, surtout lorsque le principe du pool de thread n'est pas très clair. Il est très probable que le pool de threads configuré ne soit pas meilleur. Par conséquent, certaines usines statiques sont fournies dans la classe des exécuteurs pour générer des pools de thread couramment utilisés.

1

Créez un seul pool de threads. Ce pool de threads n'a qu'un seul thread fonctionnant, ce qui équivaut à un seul thread effectuant toutes les tâches en série. Si ce fil unique se termine en raison de l'exception, il y aura un nouveau fil pour le remplacer. Ce pool de threads garantit que l'ordre d'exécution de toutes les tâches est exécuté dans l'ordre de la soumission de tâche.

2.NewFixEdThreadpool

Créez un pool de threads de taille fixe. Chaque fois qu'une tâche est soumise, un thread est créé jusqu'à ce que le thread atteigne la taille maximale du pool de threads. La taille du pool de threads reste la même une fois qu'elle atteint sa valeur maximale. Si un thread se termine en raison d'une exception d'exécution, le pool de threads ajoutera un nouveau thread.

3.NewcachedThreadpool

Créez une piscine de threads cacheable. Si la taille du pool de thread dépasse le thread requis pour traiter la tâche,

Ensuite, certains threads inactifs (aucune exécution de tâche en 60 secondes) seront recyclés. Lorsque le nombre de tâches augmente, ce pool de fils peut ajouter intelligemment de nouveaux threads pour gérer la tâche. Ce pool de thread ne limite pas la taille du pool de threads, ce qui dépend entièrement de la taille maximale du thread que le système de fonctionnement (ou JVM) peut créer.

4.NewScheduledThreadpool

Créez un pool de fil de taille illimitée. Ce pool de fils prend en charge la nécessité d'effectuer des tâches périodiquement et périodiquement.

Exemple de code

1. Pool de threads de taille fixe, NewFixEdThreadpool:

 package app.executors; Importer java.util.concurrent.executors; Importer java.util.concurrent.executorService; / ** * Thread Java: Thread Pool * * @author xiho * / public class test {public static void main (String [] args) {// Créer un pool de threads avec un nombre fixe de threads réutilisables ExecutorService pool = exécutor.NewFixEdThreadPool (2); // Créer Thread Thread T1 = new Mythread (); Thread t2 = new mythread (); Thread t3 = new mythread (); Thread t4 = new mythread (); Thread t5 = new mythread (); // Mettez le fil dans le pool pour EXECUTION POOL.EXECUTE (T1); Pool.execute (T2); Pool.execute (T3); Pool.execute (T4); Pool.execute (T5); // Fermez le fil de filetage Pool.shutdown (); }} class MyThread étend Thread {@OverRide public void run () {System.out.println (Thread.currentThread (). getName () + "Exécution ..."); }}

Résultat de sortie:

 Pool-1-thread-1 s'exécute. . . Pool-1-thread-3 s'exécute. . . Pool-1-thread-4 s'exécute. . . Pool-1-thread-2 s'exécute. . . Pool-1-thread-5 est en cours d'exécution. . .

Modifiez les paramètres dans ExecutorService Pool = Executors.NewFixEdThreadPool (5): EMIRGETORSERVICE Pool = Executors.NewFixEdThreadPool (2), et le résultat de sortie est:

 Pool-1-thread-1 s'exécute. . . Pool-1-thread-1 s'exécute. . . Pool-1-thread-2 s'exécute. . . Pool-1-thread-1 s'exécute. . . Pool-1-thread-2 s'exécute. . .

D'après les résultats ci-dessus, nous pouvons voir que le paramètre de NewFixEdThreadPool spécifie le nombre maximum de threads pouvant s'exécuter. Après avoir ajouté plus que ce nombre de threads, ils ne fonctionneront pas. Deuxièmement, les threads ajoutés au pool de threads sont à l'état géré et le fonctionnement du thread n'est pas affecté par l'ordre de jointure.

2.

Modifiez simplement le Pool ExecutorService = exécutors.NewFixEdThreadpool (2) dans le code ci-dessus en exécutor-service pool = exécutor
Résultat de sortie:

 Pool-1-thread-1 s'exécute. . . Pool-1-thread-1 s'exécute. . . Pool-1-thread-1 s'exécute. . . Pool-1-thread-1 s'exécute. . . Pool-1-thread-1 s'exécute. . .

On peut voir que chaque fois que vous appelez la méthode EXECUTE, la méthode d'exécution Thread-1 est réellement appelée à la fin.

3. Pool de threads de taille variable, NewCachedThreadpool:

Semblable à ce qui précède, modifiez simplement la façon dont le pool est créé: ExecutorService Pool = exécutors.newCachedThreadPool ();

Résultat de sortie:

 Pool-1-thread-1 s'exécute. . . Pool-1-thread-2 s'exécute. . . Pool-1-thread-4 s'exécute. . . Pool-1-thread-3 s'exécute. . . Pool-1-thread-5 est en cours d'exécution. . .

Cette méthode est caractérisée par le fait que de nouveaux pools de threads peuvent être créés au besoin, mais ils seront réutilisés lorsque des threads précédemment construits sont disponibles.

4. Pool de connexion de retard, newscheduledThreadpool:

 classe publique TestsCheDuleDThreadPoolExecutor {public static void main (String [] args) {ScheduledThreadPoolExecutor exec = new ScheduledThreadPoolExecutor (1); exec.scheduleAtFixeDrate (new Runnable () {// L'exception est déclenchée de temps en temps @Override publicVoid run () {// lance new RuntimeException (); System.out.println ("=======================================================================================================. ========================================================================================================================. ========================================================================================================================. ========================================================================================================================. TimeUnit.Milliseconds);

Résultat de sortie:

 ================ 838464454951683866438290348388643830710 ===========================================================================================================================================================================================================================.

Ce qui précède concerne cet article, j'espère qu'il sera utile à l'apprentissage de tout le monde.