Dieser Artikel analysiert vier Java -Thread -Pool -Nutzung für Ihre Referenz. Der spezifische Inhalt ist wie folgt
1. Die Nachteile des neuen Threads
Führen Sie immer noch einen neuen Thread wie folgt aus, wenn Sie eine asynchrone Aufgabe ausführen?
neuer Thread (new Runnable () {@Override public void run () {// Todo automatisch generierte Methode Stub}}). start ();Dann haben Sie zu viele Outs, die Nachteile des neuen Threads sind wie folgt:
A. Die Leistung eines neuen Threads ist jedes Mal schlecht.
B. In den Threads fehlt ein einheitliches Management, das möglicherweise neue Threads ohne Einschränkungen erzeugen, miteinander konkurrieren und zu viel Systemressourcen einnehmen kann, um Abstürze oder OOMS zu verursachen.
C. Mangel an mehr Funktionen, wie zeitgesteuerte Ausführung, regelmäßige Ausführung, Thread -Unterbrechung.
Im Vergleich zum neuen Thread sind die Vorteile der vier von Java bereitgestellten Thread -Pools:
A. Verwenden Sie vorhandene Fäden wieder, um den Overhead der Erstellung und des Aussterbens der Objekte zu verringern und eine gute Leistung zu erzielen.
B. Es kann die maximale Anzahl gleichzeitiger Threads effektiv steuern, die Nutzungsrate von Systemressourcen verbessern und übermäßige Ressourcenwettbewerbe vermeiden und eine Blockade vermeiden.
C. Bietet Funktionen wie zeitgesteuerte Ausführung, regelmäßige Ausführung, Einzel -Threading, gleichzeitige Zahlensteuerung usw.
2. Java -Threadpool
Java bietet vier Arten von Threadpools über Executors, nämlich:
NewcachedThreadpool erstellt einen zwischengespeicherbaren Fadenpool. Wenn die Länge der Gewindepool die Verarbeitungsanforderungen überschreitet, kann sie die Leerlauffäden flexibel recyceln. Wenn es keinen Recycling gibt, erstellen Sie einen neuen Thread.
Neufixed Threadpool erstellt einen Thread-Pool mit fester Länge, mit dem die maximale Anzahl von Threads gleichzeitig gesteuert werden kann, und die überschüssigen Threads warten in der Warteschlange.
NewScheduledThreadpool erstellt einen Thread-Pool mit fester Länge, der zeitgesteuerte und regelmäßige Aufgabenausführung unterstützt.
NewsingLethreadExecutor erstellt einen Thread-Pool mit einem Thread, der nur einen einzigartigen Worker-Thread verwendet, um Aufgaben auszuführen, um sicherzustellen, dass alle Aufgaben in der angegebenen Reihenfolge ausgeführt werden (FIFO, LIFO, Priorität).
(1) NewcachedThreadpool:
Erstellen Sie einen zwischengespeicherbaren Fadenpool. Wenn die Länge der Gewindepool die Verarbeitungsanforderungen überschreitet, können Sie die Leerlauffäden flexibel recyceln. Wenn es keinen Recycling gibt, erstellen Sie einen neuen Thread. Der Beispielcode lautet wie folgt:
ExecutorService CachedThreadpool = Executors.NewCachedThreadpool (); für (int i = 0; i <10; i ++) {endgültig int index = i; try {thread.sleep (index * 1000); } catch (interruptedException e) {e.printstacktrace (); } cachedThreadpool.execute (new Runnable () {@Overridepublic void run () {System.out.println (index);}});}Der Fadenpool ist unendlich. Wenn die zweite Aufgabe ausgeführt wird, wurde die erste Aufgabe erledigt, und der Thread, der die erste Aufgabe ausführt, wird jedes Mal wiederverwendet, ohne einen neuen Thread zu erstellen.
(2) NeufixedThreadpool:
Erstellen Sie einen Thread-Pool mit fester Länge, der die maximale Anzahl von Threads Gleichzeitigkeit steuern kann, und die überschüssigen Threads warten in der Warteschlange. Der Beispielcode lautet wie folgt:
ExecutorService Festthreadpool = Executors.NewFixedThreadpool (3); für (int i = 0; i <10; i ++) {endgültig 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.printStackTrace(); }}});}Da die Gewindepoolgröße 3, Schlaf 2 Sekunden nach jeder Aufgabe hat Index ausgibt, werden alle zwei Sekunden 3 Zahlen gedruckt.
Die Größe eines Threadpools mit fester Länge erfolgt am besten entsprechend den Systemressourcen. Wie runtime.getRuntime (). AFFORTEPROCESSORS (). Weitere Informationen finden Sie in Preloaddatacache.
(3) NewsschonedThreadpool:
Erstellen Sie einen Threadpool mit fester Länge, der zeitgesteuerte und regelmäßige Aufgabenausführung unterstützt. Der Beispielcode für die verzögerte Ausführung lautet wie folgt:
EnderedexecutorService afuledThreadpool = Executors.NewScheduledThreadpool (5); teplanedThreadpool.Schedule (new Runnable () {@Overridepublic void run () {System.out.println ("Delay 3 Sekunden");}}, 3, TimeUnit.seconds);Zeigt die Verzögerungsausführung um 3 Sekunden an.
Der Beispielcode wird regelmäßig wie folgt ausgeführt:
afulledThreadpool.ScheduleatFixedRate (new Runnable () {@Overridepublic void run () {System.out.println ("Verzögerung 1 Sekunden und alle 3 Sekunden");}}, 1, 3, Timeunit.Seconds);Dies bedeutet, dass die Verzögerung alle 3 Sekunden nach 1 Sekunde durchgeführt wird.
Teeduledexecutorservice ist sicherer und leistungsfähiger als Timer
(4) NewsinglethreadExecutor:
Erstellen Sie einen Thread-Pool mit einem Thread, der nur einen einzigartigen Worker-Thread verwendet, um Aufgaben auszuführen, um sicherzustellen, dass alle Aufgaben in der angegebenen Reihenfolge ausgeführt werden (FIFO, LIFO, Priorität). Der Beispielcode lautet wie folgt:
ExecutorService SinglethreadExecutor = Executors.Newsinglethreexecutor (); für (int i = 0; i <10; i ++) {endgültig int index = i; SingletheadExecutor.execute (New Runnable () {@overridepublic void run () {{try). (InterruptedException E) {// Todo automatisch erzeugt Block E. PrintstackTrace ();}}});};Die Ergebnisse werden nacheinander ausgegeben, was der Ausführung jeder Aufgabe entsprechend entspricht.
Die meisten aktuellen GUI-Programme sind Single-Threaded. Ein einzelne Threads in Android können für Datenbankvorgänge, Dateioperationen, Stapelinstallation von Anwendungen, Stapeldeletion von Anwendungen usw. verwendet werden, die nicht für gleichzeitige geeignet sind, aber IOs blockieren und die Reaktion von UI -Threads beeinflussen können.
Die Funktion des Threadpools:
Die Funktion eines Threadpools besteht darin, die Anzahl der im System ausgeführten Threads zu begrenzen.
Abhängig von der Systemumgebung kann die Anzahl der Threads automatisch oder manuell eingestellt werden, um den besten Betriebseffekt zu erzielen. Weniger Systemressourcen werden verschwendet und mehr Systemstaus ist nicht hoch. Verwenden Sie einen Thread -Pool, um die Anzahl der Threads zu steuern, und andere Threads warten in der Linie. Nachdem eine Aufgabe ausgeführt wurde, wird die erste Aufgabe aus der Warteschlange übernommen, um die Ausführung zu starten. Wenn in der Warteschlange kein Wartevorgang vorhanden ist, wartet diese Ressource des Thread -Pools. Wenn eine neue Aufgabe ausgeführt werden muss und im Thread -Pool wartende Worker -Threads vorhanden sind, kann sie ausgeführt werden. Andernfalls wird die wartende Warteschlange eingetragen.
Warum Thread Pool verwenden:
1. Reduziert die Häufigkeit, in der Threads erstellt und zerstört werden, und jeder Arbeiter -Thread kann wiederverwendet werden und mehrere Aufgaben ausführen.
2. Die Anzahl der Worker -Threads im Thread -Pool kann gemäß der Fähigkeit des Systems angepasst werden, dass der Server aufgrund eines übermäßigen Speicherverbrauchs abgesaugt wird (für jeden Thread ist etwa 1 MB Speicher erforderlich. Je mehr Threads geöffnet sind, desto größer ist der Verbrauch und schließlich der Absturz.
Die obere Oberfläche des Thread-Pools in Java ist Executor, aber streng genommen ist Executor kein Threadpool, sondern nur ein Tool zum Ausführen von Threads. Die reale Thread -Pool -Schnittstelle ist Executorservice.
Einige wichtige Kategorien:
ExecutorService: Eine echte Thread -Pool -Schnittstelle.
ScheduledexecutorService: Es kann dem Timer/TimerTask ähneln und Probleme lösen, die wiederholte Aufgaben erfordern.
ThreadPoolexecutor: Die Standardimplementierung von ExecutorService.
ScheduledThreadPoolexecutor: Eine Klassenimplementierung der geplantenxecutorservice -Schnittstelle, die ThreadPoolexecutor erbt, eine regelmäßige Aufgabenplanungsklassen -Implementierung.
Es ist ziemlich kompliziert, einen Thread -Pool zu konfigurieren, insbesondere wenn das Prinzip des Thread -Pools nicht sehr klar ist. Es ist sehr wahrscheinlich, dass der konfigurierte Threadpool nicht besser ist. Daher werden einige statische Fabriken in der Executors -Klasse bereitgestellt, um einige häufig verwendete Threadpools zu generieren.
1.NewsinglethreadExecutor
Erstellen Sie einen einzelnen Threadpool. Dieser Thread -Pool hat nur einen Thread, der einem einzelnen Faden entspricht, der alle Aufgaben in der Serie ausführt. Wenn dieser einzigartige Faden aufgrund der Ausnahme endet, gibt es einen neuen Thread, der ihn ersetzt. Dieser Thread -Pool stellt sicher, dass die Ausführungsreihenfolge aller Aufgaben in der Reihenfolge der Aufgabenübermittlung ausgeführt wird.
2.NewFixed threadpool
Erstellen Sie einen Threadpool mit fester Größe. Jedes Mal, wenn eine Aufgabe übermittelt wird, wird ein Thread erstellt, bis der Thread die maximale Größe des Threadpools erreicht. Die Gewindepoolgröße bleibt gleich, sobald sie ihren Maximalwert erreicht. Wenn ein Thread aufgrund einer Ausführungsausnahme endet, fügt der Thread -Pool einen neuen Thread hinzu.
3.NewcachedThreadpool
Erstellen Sie einen zwischengespeicherbaren Fadenpool. Wenn die Gewindepoolgröße den Thread überschreitet, der zur Verarbeitung der Aufgabe erforderlich ist,
Dann werden einige müßige Threads (keine Aufgabenausführung in 60 Sekunden) recycelt. Wenn die Anzahl der Aufgaben zunimmt, kann dieser Thread -Pool intelligent neue Threads hinzufügen, um die Aufgabe zu verarbeiten. Dieser Thread -Pool begrenzt nicht die Gewindepoolgröße, die vollständig von der maximalen Gewindegröße abhängt, die das Betriebssystem (oder JVM) erstellen kann.
4.NewSeuered threadpool
Erstellen Sie einen Thread -Pool unbegrenzter Größe. Dieser Thread -Pool unterstützt die Notwendigkeit, Aufgaben regelmäßig und regelmäßig auszuführen.
Beispielcode
1. Threadpool mit fester Größe, NeufixedThreadpool:
Paket app.executors; import Java.util.concurrent.executors; import Java.util.concurrent.executorService; / ** * Java -Thread: Threadpool * * @Author xiho */ public class test {public static void main (String [] args) {// Erstellen Sie einen Thread -Pool mit einer festen Anzahl wiederverwendbarer Threads Executorservice Pool = Executors.Newfixed threadpool (2); // Thread Thread erstellen t1 = new myThread (); Thread T2 = neuer myThread (); Thread T3 = neuer MyThread (); Thread T4 = neuer myThread (); Thread T5 = neuer MyThread (); // den Thread in den Pool für Ausführung pool.execute (t1) in den Pool einfügen; pool.execute (t2); pool.execute (t3); pool.execute (t4); pool.execute (t5); // Schließen Sie den Thread Pool pool.shutdown (); }} class myThread erweitert Thread {@Override public void run () {System.out.println (Thread.currentThread (). getName () + "Ausführung ..."); }}Ausgangsergebnis:
Pool-1-Thread-1 wird ausgeführt. . . Pool-1-Thread-3 wird ausgeführt. . . Pool-1-Thread-4 wird ausgeführt. . . Pool-1-Thread-2 wird ausgeführt. . . Pool-1-Thread-5 wird ausgeführt. . .
Ändern Sie die Parameter im ExecutorService Pool = Executors.NewFixed threadpool (5): ExecutorService Pool = Executors.NewFixedThreadpool (2), und das Ausgabeergebnis lautet:
Pool-1-Thread-1 wird ausgeführt. . . Pool-1-Thread-1 wird ausgeführt. . . Pool-1-Thread-2 wird ausgeführt. . . Pool-1-Thread-1 wird ausgeführt. . . Pool-1-Thread-2 wird ausgeführt. . .
Aus den obigen Ergebnissen können wir sehen, dass der Parameter von NeufixedThreadpool die maximale Anzahl der ausgeführten Threads angibt. Nachdem sie mehr als diese Anzahl von Threads hinzugefügt haben, werden sie nicht ausgeführt. Zweitens befinden sich die dem Thread Pool hinzugefügten Threads im verwalteten Zustand, und der Betrieb des Threads wird nicht von der Verbindungsreihenfolge beeinflusst.
2. Ein Task -Thread -Pool, NewsingLethreadExecutor:
Ändern Sie einfach den ExecutorService Pool = Executors.NewFixed threadpool (2) im obigen Code zum ExecutorService Pool = Executors.
Ausgangsergebnis:
Pool-1-Thread-1 wird ausgeführt. . . Pool-1-Thread-1 wird ausgeführt. . . Pool-1-Thread-1 wird ausgeführt. . . Pool-1-Thread-1 wird ausgeführt. . . Pool-1-Thread-1 wird ausgeführt. . .
Es ist ersichtlich, dass jedes Mal, wenn Sie die Ausführungsmethode aufrufen, die Thread-1-Auslaufmethode tatsächlich am Ende aufgerufen wird.
3. Thread Pool variabler Größe, New geschachter Threadpool:
Ähnlich wie die oben genannten, ändern Sie einfach die Art und Weise, wie der Pool erstellt wird: ExecutorService Pool = Executors.NewcachedThreadpool ();
Ausgangsergebnis:
Pool-1-Thread-1 wird ausgeführt. . . Pool-1-Thread-2 wird ausgeführt. . . Pool-1-Thread-4 wird ausgeführt. . . Pool-1-Thread-3 wird ausgeführt. . . Pool-1-Thread-5 wird ausgeführt. . .
Diese Methode ist durch die Tatsache gekennzeichnet, dass neue Threadpools nach Bedarf erstellt werden können, sie werden jedoch wiederverwendet, wenn zuvor konstruierte Threads verfügbar sind.
4.. Verzögerungsverbindungspool, NewsschonedThreadpool:
public class testseduledThreadpoolexecutor {public static void main (String [] args) {teplanedThreadpoolexecutor exec = new ScheduledThreadpoolexecutor (1); exec.SchedueatFixedRate (new Runnable () {// Ausnahme wird hin und wieder ausgelöst @Override publicVoid run () {// neue runTimeexception () werfen; System.out.println("=============================================================================== ==========================================================ieben ==========================================================ieben ==========================================================ieben TimeUnit.Milliseconds);Ausgangsergebnis:
=============== 838464454951683866438290348388643830710 ================ 8390643851383839264387939398400643939383
Das Obige dreht sich alles um diesen Artikel, ich hoffe, es wird für das Lernen aller hilfreich sein.