In den folgenden Beispielen werden hauptsächlich zwei Themen erörtert:
Frage 1. Der Gewindepool ist in der Größe festgelegt, vorausgesetzt, er ist 5. Wie ist der Betriebseffekt des Einlegens von 10 Fäden in den Fadenpool? Der Status anderer Threads?
Frage 2. Wie entfernen Sie einen Faden aus dem Fadenpool oder um genau zu sein, um einen Faden zu einem Leerlauffaden zu machen?
Beispiel:
Paket com.dada.executorservice; Import Java.util.Concurrent.TimeUnit; öffentliche Klasse JobThread erweitert Thread {// Nenne den Thread Public JobThread (String -Name, langer ThreadID) {Super (Name); } @Override public void run () {// Wenn der Haupt-Thread diesen Thread enthält, wird er ausgeführt (minarthead.threadnamemap.containsKey (this.getName ()))) {try {System.out.println ("Thread Name: ------" + this.getName ()); TimeUnit.seconds.sleep (4); } catch (Ausnahme e) {e.printstacktrace (); }} System.out.println ("**************** endet, Threadname: ***************" + this.getName ()); }} Paket com.dada.executorservice; import Java.util.hashMap; import Java.util.concurrent.executorService; import Java.util.concurrent.executors; Import Java.util.Concurrent.TimeUnit; public class Mainthead {public static final int threadpool_size = 5; // generieren Sie einen Thread Pool mit fester Größe, der öffentliche statische Ausführende EXEC = Executors.NewFixedThreadpool (Threadpool_Size); // Karte zum Speichern von Threadnamen öffentliche statische Karte <String, String> ThreadNamemap = New HashMap <String, String> (); public static void main (String [] args) {// 10 Threads in den Thread -Pool einfügen, aber der Thread -Pool ermöglicht nur maximal 5 Threads, sodass die anderen 5 Threads warten (int i = 0; i <threadpool_size+5; i ++) {String threadName = getTheadname (i); threadnamemap.put (ThreadName, ThreadName); exec.execute (neuer jobthread (threadName, i)); } System.out.println ("Größe der Hash -Tabelle:" + threadnamemap.size ()); Versuchen Sie {System.out.println ("Der Hauptfaden schläft eine Weile!"); TimeUnit.seconds.sleep (3); } catch (Ausnahme e) {e.printstacktrace (); System.out.println ("Wake Up!"); } // Folgendes werden verwendet, um Threads im Thread -Pool zu löschen // removethread (0); // Removethread (1); // Removethread (2); } public static void removethread (int i) {threadnamemap.remove (GetThreadName (i)); System.out.println ("ThreadThread" + i + ", die Größe der Hash -Tabelle:" + Threadnamemap.size ()); } public static String getThreadName (int i) {return "threadName"+i; }} Führen Sie das Codeergebnis direkt aus:
Threadname: ------ ThreadName0
Die Größe des Hash -Tabelle: 10
Schlafen Sie für eine Weile am Hauptfaden!
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
abschließend:
Gedruckt gefunden: Der Thread -Name wurde von ThreadName0 bis ThreadName4, kein anderer Name, stammt.
Es ist bewiesen, dass 10 Fäden in den Gewindepool platziert werden, aber die Größe des Fadenpools beträgt 5 und nur 5 Fäden können CPUs zugewiesen werden. Das laufende ist der erste, der in den Thread -Pool eingebaut wird, und die anderen Fäden befinden sich im bereiten Zustand (Blockierungszustand).
Nach dem Entfernen der Kommentare wird der Code ausgeführt:
Threadname: ------ ThreadName0
Threadname: ------ ThreadName2
Threadname: ------ ThreadName4
Die Größe des Hash -Tabelle: 10
Schlafen Sie für eine Weile am Hauptfaden!
Threadname: ------ ThreadName1
Threadname: ------ ThreadName3
Thread Thread0 löschen, die Größe der Hash -Tabelle: 9
Thread Thread1 löschen, die Größe der Hash -Tabelle: 8
Thread Thread2 löschen, die Größe der Hash -Tabelle: 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
abschließend:
Aus den Ergebnissen können wir sehen, dass der laufende Thread vor dem Entfernen des Threads immer noch von Thread0 bis Thread4 ist. Nach dem Entfernen von Thread -Thread 0 beginnt der neue Thread -Thread3 und er geht in die Reihenfolge zu ThreadName7.
Die Zusammenfassung lautet wie folgt:
1. Der Gewindepool ist in der Größe festgelegt, vorausgesetzt, er ist 5. Wie ist der Betriebseffekt des Einlegens von 10 Fäden in den Gewindepool? Der Status anderer Threads?
A. Das Konzept des Thread -Pools besteht darin, dass Sie weiterhin Anfragen darauf drücken, aber nur Threads mit angegebenen Quoten verarbeiten können, und zusätzliche Threads warten darin.
B. Wenn einer der Threads die Verarbeitung abgeschlossen hat (die Geschäftsausführung wird abgeschlossen oder die Schleife beendet), nimmt der Thread -Pool automatisch einen Job aus der wartenden Warteschlange heraus und verwendet einen Leerlauf -Thread, um den Auftrag auszuführen. Welcher Thread -Pool im laufenden Thread -Pool sollte auf der Reihenfolge basieren, in der er platziert wird.
2. Wie entfernen Sie also einen Faden aus dem Fadenpool oder um genau zu sein, um einen Faden zu einem Leerlauffaden zu machen?
Der Thread -Pool kann keinen der Fäden erhalten und töten, da der Hauptfaden mit dem Fadenpool und den vom Hauptfaden geöffneten Fäden auf derselben Ebene liegen und niemand das Recht hat, das Überleben der anderen Partei zu dominieren. Sie können die Methode jedoch ändern und das Ziel taktvoll erreichen.
A. Der Hauptfaden führt eine Hash -Tabelle bei, die ein HashMap sein kann. Der Schlüsselwert ist willkürlich, muss jedoch einzigartig sein und kann ein einzigartiges Faden anzeigen.
B. Alle im Thread Pool platzierten Threads müssen einen Schlüsselwert generieren und dann in diesem HashMap speichern.
C. Für Threads der Schleifenklasse, wie z. B. Threads von while (wahr). Eine Bedingung muss hinzugefügt werden, um zu überprüfen, ob der Schlüssel dieses Threads in der obigen HashMap vorhanden ist. Beenden Sie die while -Schleife, wenn es nicht existiert.
D. Obwohl der Hauptfaden das Überleben anderer Fäden nicht dominieren kann, kann er seinen eigenen Hashmap einstellen oder entfernen. An diesem Punkt, solange der entsprechende Schlüsselwert des Threads aus dem HashMap entfernt wird, wird der Thread automatisch beim nächsten Schleifen beendet.
Das obige ist der gesamte Inhalt dieses Artikels. Ich hoffe, es wird für das Lernen aller hilfreich sein und ich hoffe, jeder wird Wulin.com mehr unterstützen.