Die Kosten für den Start eines Fadens im System sind relativ hoch, da es sich um eine Interaktion mit dem Betriebssystem handelt. Der Vorteil der Verwendung eines Thread -Pools besteht darin, die Leistung zu verbessern. Wenn das System eine große Anzahl von gleichzeitigen Fäden enthält, führt dies zu einem starken Rückgang der Systemleistung und sogar zum Absturz von JVM. Die maximale Anzahl von Threads im Thread -Pool -Parameter kann die Anzahl der gleichzeitigen Threads im System steuern, um die Anzahl der Male nicht zu überschreiten.
1. Die Fabrikklasse ausführende Fabrikklasse wird verwendet, um einen Thread -Pool zu generieren . Diese Werksklasse enthält die folgenden statischen Fabrikmethoden, um den entsprechenden Thread -Pool zu erstellen. Der erstellte Thread -Pool ist ein ausführender Objekt. Die Sendemethode des Objekts oder die Ausführungsmethode zum Ausführen der entsprechenden Ausgaben oder auf dem neuesten Stand auszuführen. Der Thread -Pool selbst ruft die Shutdown () -Methode auf, um den Thread -Pool zu stoppen, wenn er nicht mehr benötigt wird. Nach dem Aufrufen der Methode erlaubt der Thread -Pool keine Aufgaben mehr, sondern sterben nicht, bis alle zusätzlichen Aufgaben ausgeführt wurden.
1. NewcachedThreadpool () erstellt einen Thread -Pool mit Caching -Funktion und legt den von der Aufgabe erstellten Thread (Runnable oder Callable -Objekt) des Thread -Pools ein. Wenn die Ausführung abgeschlossen ist, wird sie für die Verwendung der Aufgaben, die später ausgeführt werden müssen, in das zwischengespeicherte Threadpool zwischengespeichert.
importieren java.util.concurrent.executorService; import Java.util.concurrent Thread.currentThread (). GetAllstacktraces (). Size ()); }} public static void main (String [] args) {ExecutorService Cachethreadpool = Executors.NewCachedThreadpool (); // Fügen Sie dem Thread -Pool zuerst drei Aufgaben hinzu für (int i = 0; i <3; i ++) {cachethreadpool.execute (new Task ()); } // Nachdem die drei Threads ausgeführt wurden, fügen Sie dem Thread -Pool erneut drei Aufgaben hinzu, versuchen Sie erneut {Thread.sleep (3000); } catch (interruptedException e) {e.printstacktrace (); } für (int i = 0; i <3; i ++) {cachethreadpool.execute (new Task ()); }}}Die Ausführungsergebnisse sind wie folgt:
CacheThreadPool$Task@2d312eb9 pool-1-thread-1 AllStackTraces map size: 7CacheThreadPool$Task@59522b86 pool-1-thread-3 AllStackTraces map size: 7CacheThreadPool$Task@73dbb89f pool-1-thread-2 AllStackTraces map size: 7CacheThreadPool$Task@5795cedc Pool-1-Thread-3 Allstacktraces Map-Größe: 7Cachetheadpool $ task@256D5600 Pool-1-thread-1 Allstacktraces Map-Größe: 7Cachethreadpool $ task@7d1c5894 Pool-1-Thread-2 Allstacktraces Mapgröße: 7
Threadobjekte im Thread -Pool werden zwischengespeichert und wiederverwendet, wenn neue Aufgaben ausgeführt werden. Wenn es jedoch eine Menge Gleichzeitigkeit gibt, erstellt der Cache -Thread -Pool weiterhin viele Thread -Objekte.
2. Newfixed threadpool (int nthreads) erstellt einen Thread -Pool mit einer bestimmten Anzahl von Threads, die von Threads wiederverwendet werden können.
importieren java.util.concurrent.executorService; import Java.util.concurrent Thread.currentThread (). GetAllstacktraces (). Size ()); }} public static void main (String [] args) {ExecutorService Festthreadpool = Executors.NewFixedThreadpool (3); // Fügen Sie dem Thread -Pool zuerst drei Aufgaben hinzu für (int i = 0; i <5; i ++) {Festeadpool.execute (new Task ()); } // Nachdem die drei Threads ausgeführt wurden, fügen Sie dem Thread -Pool erneut drei Aufgaben hinzu, versuchen Sie erneut {Thread.sleep (3); } catch (interruptedException e) {e.printstacktrace (); } für (int i = 0; i <3; i ++) {Festeadpool.execute (new Task ()); }}}Ausführungsergebnisse:
FixedThreadpool $ Task@7045C12D Pool-1-thread-2 Allstacktraces Map-Größe: 7FixedThreadpool $ Task@50fa0bef Pool-1-thread-2 Allstacktraces Mapgröße: 7FixedPool $ Task@ccb1870 Pool-1-thead-2---S-Tacktraces: 7fixedPool $ -Map-1 --1-12-Threadpool: 7FixeDpool@ccb1870@7392b4 Map-1 --1 --1 --1-1 --1-1-2---M-Map-ThreadPool@Task@7392b4 MAP-THEME3 MAP-THEDTHREIGE: AllStacktraces Mapgröße: 7FixedThreadpool $ Task@5bdeff18 Pool-1-Thread-2 Allstacktraces Mapgröße: 7FixedThreadpool $ task@7d554e1 Pool-1-1-Thread-1 Allstacktraces Mapgröße: 7Fixed theadpool $ task@24468092 Pool-1-1-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-3-Thread-3-3-3-Thread-3-3-3-3-3-3-Thread-3-3-3-3-Thread-3-3-3-Thread-3-3-Thread-3-3-Thread-3-3-Thread-3-3-Thread. 7FixedThreadpool $ task@fa7b978 Pool-1-thread-2 Allstacktraces MAP-Größe: 7
3.. NewsinglethreadExecutor (), erstellen Sie einen Thread -Pool mit nur einzelnen Threads, was dem aufgerufenen NeufixedThreadpool entspricht (1)
V. Sie können einen Thread auch in einem bestimmten Zeitraum wiederholen, da Sie wissen, dass Sie das Shutdown () anrufen können, um den Thread -Pool zu schließen.
Beispiele sind wie folgt:
importieren java.util.concurrent.executors; import Java.util.concurrent "" + Thread.currentThread (). GetName () + "Allstacktraces Map -Größe:" + thread.currentThread (). GetAllStacktraces (). Size ()); }} public static void main (String [] args) {plantedexecutorService afuledexecutorService = Executors.NewScheduledThreadpool (3); enderedexecutorService.Schedule (neue Task (), 3, TimeUnit.seconds); enderedexecutorService.ScheduleatFixedrat (New Task (), 3, 5, TimeUnit.Seconds); try {thread.sleep (30 * 1000); } catch (interruptedException e) {e.printstacktrace (); } planedexecutorService.shutdown (); }}Die Betriebsergebnisse sind wie folgt:
Zeit 1458921795240 Pool-1-thread-1 Allstacktraces MAP-Größe: 6Time 1458921795241 Pool-1-Thread-2 Allstacktraces MAP-Größe: 6Time 1458921800240 Pool-1-1-Thread-1 Allstacktraces MAPS-Größe: 7Time 1458921810240 Pool-1-Thread-1 Allstacktraces Map-Größe: 7Time 1458921815240 Pool-1-Thread-1 Allstacktraces MAP-Größe: 7 Zeit 1458921820240 Pool-1-Thread-1 Allstacktraces Mapgröße: 7 7
Wie aus der Laufzeit ersichtlich ist, wird die Aufgabe in einem 5-Sekunden-Zyklus ausgeführt.
5. NewsinglethreadScheduledexecutor () erstellt einen Thread -Pool mit nur einem Thread und ruft NewScheduled Threadpool (1) auf.
2. Forkjoinpool und Forkjointaskask
Forkjoinpool ist eine Implementierungsklasse von Executorservice. Es unterstützt die Aufteilung einer Aufgabe in mehrere kleine Aufgaben im parallelen Computer und die Kombination der Berechnungsergebnisse mehrerer kleiner Aufgaben in die Gesamtberechnungsergebnisse. Es hat zwei Konstruktoren
Forkjoinpool (int Parallelität) schafft eine Forkjoinpool, die Parallelitätsthreads enthält.
Forkjoinpool () erstellt Forkjoinpool unter Verwendung des Rückgabewerts der Laufzeit.
Forkjointask repräsentiert eine Aufgabe, die parallel und zusammengeführt werden kann. Es handelt sich um eine abstrakte Klasse, die die zukünftige <T> -Kinterface implementiert. Es verfügt über zwei abstrakte Unterklassen, die die Recuriveaction der Aufgabe ohne Rückgabewert und die Rekursivtaskierung mit einem Rückgabewert darstellen. Sie können diese beiden abstrakten Klassen entsprechend den spezifischen Bedürfnissen erben, um Ihre eigenen Objekte zu implementieren, und dann die Subing -Methode von Forkjoinpool zur Ausführung aufrufen.
Das Recuriveaction-Beispiel lautet wie folgt und implementiert parallele Ausgänge von 0-300-Zahlen.
import Java.util.concurrent.forkjoinpool; import java.util.concurrent privat int start; privates int Ende; public Printask (int start, int End) {this.start = start; this.end = Ende; } @Override protected void compute () {if (end - start <threshold) {für (int i = start; i <end; i ++) {System.out.println (Thread.currentThread (). GetName () + " + i); }} else {int Middle = (start + end) / 2; PrintTask links = new Printask (Start, Mitte); PrintTask Right = New Printask (Mitte, Ende); links.Fork (); rechts.Fork (); }}} public static void main (String [] args) {forkjoinpool pool = new forkjoinpool (); pool.submit (neuer Printkask (0, 300)); try {pool.awaittermination (2, timeUnit.seconds); } catch (interruptedException e) {e.printstacktrace (); } pool.shutdown (); }}Nachdem Sie die kleine Aufgabe geteilt haben, rufen Sie die Fork () -Methode der Aufgabe an und fügen Sie sie zur Ausführung parallel zum Forkjoinpool hinzu.
Reursivetask -Beispiel implementiert eine parallele Berechnung von 100 Ganzzahlen, um zu summieren. In alle 20 Zahlen aufgeteilt und summieren Sie sie, um das Ergebnis zu erzielen, und fusionieren Sie sie am Ende in das Endergebnis.
Import Java.util.random; Import Java.util.concurrent.executionException; Import Java.util.Concurrent {private statische endgültige int -Schwelle = 20; private int arr []; privat int start; privates int Ende; public Caltask (int [] arr, int start, int end) {this.arr = arr; this.start = start; this.end = Ende; } @Override Protected Integer compute () {int sum = 0; if (end - start <threshold) {for (int i = start; i <end; i ++) {sum+= arr [i]; } System.out.println (Thread.currentThread (). GetName () + "sum:" + sum); Rückgabesumme; } else {int Middle = (Start + Ende) / 2; Caltask links = New Caltask (arr, start, Mitte); Caltask Right = New Caltask (arr, Mitte, Ende); links.Fork (); rechts.Fork (); return links.join () + rechts.Join (); }}} public static void main (String [] args) {int arr [] = new int [100]; Random random = new random (); int total = 0; für (int i = 0; i <arr.length; i ++) {int tmp = random.nextint (20); Gesamt += (arr [i] = tmp); } System.out.println ("Gesamt" + Gesamt); Forkjoinpool Pool = New Forkjoinpool (4); Future <Ganzzahl> Future = Pool.Submit (neuer Caltask (arr, 0, arr.length)); try {system.out.println ("CAL -Ergebnis:" + future.get ()); } catch (interruptedException e) {e.printstacktrace (); } catch (executionException) e) {e.printstacktrace (); } pool.shutdown (); }}Die Ausführungsergebnisse sind wie folgt:
total 912ForkJoinPool-1-worker-2 sum:82ForkJoinPool-1-worker-2 sum:123ForkJoinPool-1-worker-2 sum:144ForkJoinPool-1-worker-3 sum:119ForkJoinPool-1-worker-2 sum:106ForkJoinPool-1-worker-2 sum:128ForkJoinPool-1-worker-2 Summe: 121Forkjoinpool-1-Arbeiter-3-Summe: 89Cal-Ergebnis: 912
Nachdem die Subtask ausgeführt wurde, rufen Sie die Join () -Methode der Aufgabe auf, um das Ergebnis der Subtask -Ausführung zu erhalten, und fügen Sie sie dann hinzu, um das Endergebnis zu erhalten.