Les exemples suivants discutent principalement de deux questions:
Question 1. Le pool de threads est fixé en taille, en supposant qu'il est 5. Alors, comment l'effet de fonctionnement de la mise en filetage de 10 fils dans le pool de threads? L'état des autres threads?
Question 2. Alors, comment retirez-vous un fil du pool de fil, ou pour être précis, pour faire d'un fil un fil inactif?
exemple:
package com.dada.executorService; Importer java.util.concurrent.TimeUnit; classe publique JobThread étend Thread {// Name The Thread Public JobThread (String Name, Long ThreadId) {super (name); } @Override public void run () {// Si le thread principal contient ce thread, il exécutera while (mainthread.threadnamemap.containsKey (this.getName ()))) {try {system.out.println ("thread name: -----" + this.getName ()); TimeUnit.seconds.Sleep (4); } catch (exception e) {e.printStackTrace (); }} System.out.println ("****************** Ends du fil, nom de fil: ***************" + this.getName ()); }} package com.dada.executorService; import java.util.hashmap; Importer java.util.concurrent.executorService; Importer java.util.concurrent.executors; Importer java.util.concurrent.TimeUnit; classe publique Mainthread {public static final int threadpool_size = 5; // Générez un filetage fixe filetage public static exécutorService exec = exécutor.newFixEdThreadpool (ThreadPool_Size); // map utilisée pour stocker les noms de threads publics static map <string, string> threadNameMap = new HashMap <String, String> (); public static void main (String [] args) {// insérer 10 threads dans le pool de threads, mais le pool de threads n'autorise qu'un maximum de 5 threads, de sorte que les 5 autres threads attendent (int i = 0; i <threadpool_size + 5; i ++) {String ThreadName = GetThreadName (i); thewnamemap.put (ThreadName, ThreadName); exec.execute (new JobThread (ThreadName, i)); } System.out.println ("Taille de la table de hachage:" + ThreadNameMap.Size ()); essayez {System.out.println ("Le fil principal dort pendant un certain temps!"); TimeUnit.seconds.Sleep (3); } catch (exception e) {e.printStackTrace (); System.out.println ("Wake Up!"); } // Les éléments suivants sont utilisés pour supprimer les threads dans le fil de thread // supprimer (0); // supprimer (1); // supprimer (2); } public static void supprime (int i) {threadnamemap.reMove (getThreadName (i)); System.out.println ("Delete Threadthread" + I + ", la taille de la table de hachage:" + ThreadNameMap.size ()); } public static String getThreadName (int i) {return "ThreadName" + i; }} Exécutez directement le résultat du code:
ThreadName: ------ ThreadName0
La taille du tableau du hachage: 10
Dormez un moment sur le fil principal!
ThreadName: ------ ThreadName2
ThreadName: ------ ThreadName4
ThreadName: ------ ThreadName1
ThreadName: ------ ThreadName3
ThreadName: ------ ThreadName4
ThreadName: ------ ThreadName2
ThreadName: ------ ThreadName3
ThreadName: ------ ThreadName1
ThreadName: ------ ThreadName0
ThreadName: ------ ThreadName1
ThreadName: ------ ThreadName3
ThreadName: ------ ThreadName0
ThreadName: ------ ThreadName4
ThreadName: ------ ThreadName2
ThreadName: ------ ThreadName1
ThreadName: ------ ThreadName3
ThreadName: ------ ThreadName4
en conclusion:
Trouvé imprimé: le nom de thread est passé de ThreadName0 à ThreadName4, aucun autre nom.
Il est prouvé que 10 threads sont placés dans le pool de threads, mais la taille du pool de threads est de 5, et seulement 5 fils peuvent être alloués de processeurs. Celui qui fonctionne est le premier à mettre dans le pool de fils, et les autres threads sont à l'état prêt (état de blocage).
Après avoir supprimé les commentaires, le code s'exécute:
ThreadName: ------ ThreadName0
ThreadName: ------ ThreadName2
ThreadName: ------ ThreadName4
La taille du tableau du hachage: 10
Dormez un moment sur le fil principal!
ThreadName: ------ ThreadName1
ThreadName: ------ ThreadName3
Supprimer le thread thread0, la taille de la table de hachage: 9
Supprimer thread thread1, la taille de la table de hachage: 8
Supprimer le thread thread2, la taille de la table de hachage: 7
***********.
***********.
ThreadName: ------ ThreadName5
ThreadName: ------ ThreadName6
***********.
ThreadName: ------ ThreadName4
ThreadName: ------ ThreadName7
ThreadName: ------ ThreadName3
ThreadName: ------ ThreadName6
ThreadName: ------ ThreadName5
ThreadName: ------ ThreadName7
ThreadName: ------ ThreadName4
ThreadName: ------ ThreadName3
ThreadName: ------ ThreadName5
ThreadName: ------ ThreadName6
ThreadName: ------ ThreadName7
ThreadName: ------ ThreadName4
ThreadName: ------ ThreadName3
en conclusion:
D'après les résultats, nous pouvons voir qu'avant de retirer le thread, le thread en cours d'exécution est toujours de Thread0 à Thread4. Après avoir retiré le fil de fil 0, le nouveau thread Thread3 commence à s'exécuter et il va sur ThreadName7 dans l'ordre.
Le résumé est le suivant:
1. Le pool de threads est fixé en taille, en supposant qu'il est 5. Alors, comment est l'effet de fonctionnement de mettre 10 threads dans le pool de threads? L'état des autres threads?
un. Le concept de pool de threads est que vous continuez à pousser les demandes, mais il ne peut gérer que des threads avec des quotas spécifiés, et les threads supplémentaires y attendent.
né Lorsque l'un des threads a terminé le traitement (l'exécution commerciale est terminée ou la boucle while est sortie), le pool de threads supprimera automatiquement un travail à partir de la file d'attente d'attente et utilisera un fil inactif pour exécuter le travail. Quel pool de thread dans le pool de threads en cours d'exécution doit être basé sur l'ordre dans lequel il est passé.
2. Alors, comment supprimer un fil du pool de filetage, ou pour être précis, pour faire d'un fil un fil inactif?
Le pool de thread ne peut pas obtenir l'un des fils et le tuer car le thread principal utilisant le pool de threads et les fils ouverts par le fil principal sont au même niveau, et personne n'a le droit de dominer la survie de l'autre partie. Mais vous pouvez modifier la méthode et atteindre l'objectif de manière délicate.
un. Le fil principal maintient une table de hachage qui peut être un hashmap. La valeur clé est arbitraire, mais elle doit être unique et peut indiquer de manière unique un thread.
né Tous les threads placés dans le pool de threads doivent générer une valeur de clé, puis le stocker dans ce hashmap.
c. Pour les threads de la classe Loop, tels que les fils de While (true). Une condition doit être ajoutée pour vérifier si la clé de ce thread existe dans le hashmap ci-dessus. Quittez la boucle while si elle n'existe pas.
d. Bien que le thread principal ne puisse pas dominer la survie des autres threads, il peut mettre ou supprimer son propre hashmap. À ce stade, tant que la valeur de clé correspondante du thread est supprimée du hashmap, le thread quittera automatiquement la prochaine fois qu'il bouclera.
Ce qui précède est tout le contenu de cet article. J'espère que cela sera utile à l'apprentissage de tous et j'espère que tout le monde soutiendra davantage Wulin.com.