Detaillierte Erklärung der Verwendung von vier Threadpools in Java Executorservice

1. Einführung

Die rationale Verwendung von Threadpools kann drei Vorteile bringen. Erstens: Reduzieren Sie den Ressourcenverbrauch. Reduzieren Sie den Verbrauch, der durch die Erstellung und Zerstörung von Fäden verursacht wird, indem er erstellte Themen wiederverwendet. Zweitens: Verbesserung der Reaktionsgeschwindigkeit. Wenn eine Aufgabe ankommt, kann die Aufgabe unmittelbar nach dem Erstellen des Threads ausgeführt werden. Drittens: Verbesserung der Thread -Verwaltbarkeit. Themen sind knappe Ressourcen. Wenn sie unbegrenzt erstellt werden, konsumieren sie nicht nur Systemressourcen, sondern reduzieren auch die Stabilität des Systems. Die Verwendung von Threadpools kann eine einheitliche Zuordnung, Abstimmung und Überwachung sein. Um jedoch die rationale Verwendung von Thread -Pools zu nutzen, müssen Sie seine Prinzipien gut kennen.

2. Nutzung von Fadenbecken

Die vier Arten von Themen, die von Executors 1.NewCachedThreadpool bereitgestellt werden, erzeugt einen zwischengestellten Thread -Pool. 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. 2.NewFixed threadpool erstellt einen Thread-Pool mit fester Länge, mit dem die maximale Anzahl von Threads Parallelance steuern kann, und die überschüssigen Threads warten in der Warteschlange. 3.NewSeuered threadpool erstellt einen Thread-Pool mit fester Länge, der zeitgesteuerte und regelmäßige Aufgabenausführung unterstützt. 4.NesinglethreadExecutor erstellt einen Thread-Pool mit einem Thread, der nur einen einzigartigen Arbeiter-Thread verwendet, um Aufgaben auszuführen, um sicherzustellen, dass alle Aufgaben in der angegebenen Reihenfolge ausgeführt werden (FIFO, LIFO, Priorität).

1.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. Das Beispiel ist wie folgt

 ExecutorService ExecutorService = Executors.NewCachedThreadpool (); für (int i = 0; i <5; i ++) {endgültig int index = i; try {thread.sleep (index * 1000); } catch (interruptedException e) {e.printstacktrace (); } ExecutorService.execute (new Runnable () {@Override public void run () {System.out.println (Thread.currentThread (). getName () + "," + index);}});} // Konsoleninformationen Pool-1-thread-1,0pool-1-thread-1,1pool-1-thread-1,2pool-1-thread-1,3pool-1-Thread-1,4

2.NewFixed threadpool erstellt einen Thread-Pool mit fester Länge, mit dem die maximale Anzahl von Threads Parallelance steuern kann, und die überschüssigen Threads warten in der Warteschlange. Das Beispiel ist wie folgt

 ExecutorService Festthreadpool = Executors.NewFixedThreadpool (4); für (int i = 0; i <5; i ++) {endgültig int index = i; FixedThreadpool.execute (new Runnable () {@Override public void run () {try {System.out.println (thread.currentThread (). getName () + "," + index); thread.sleep (2000); Pool-1-thread-1,0pool-1-thread-2,1pool-1-thread-3,2pool-1-thread-4,3pool-1-Thread-1,4

3.NewScheduled threadpool erstellen einen Fadenpool mit fester Länge, und die Beispiele für Stützzyklen und Zeitaufgaben sind wie folgt wie folgt

 EnderedexecutorService afulledThreadpool = Executors.NewScheduledThreadpool (5); System.out.println ("Bevor:" + System.CurrentTimemillis ()/1000); plantedThreadpool.schsplan (new Runnable () {@Override public void run () {System.out.println ("Verzögerte Ausführung für 3 Sekunden:" + System.currentTimemillis ()/1000);}}, 3, Timeunit.Seconds). +System.currentTimemillis ()/1000); // Konsoleninformationen Vorher: 1518012703af: 1518012703 für 3 Sekunden verzögert: 1518012706System.out.println ("Vorher:" +System.curentTimememillis ()/1000); {@Override public void run () {System.out.println ("Nach Verzögerung von 1 Sekunde, einmal in 3 Sekunden ausführen:" +System.CurrentTimemillis ()/1000);

Konsolennachricht
Vorher: 1518013024
Nach: 1518013024
Nach 1 Sekunde Verzögerung einmal in 3 Sekunden ausführen: 1518013025
Nach 1 Sekunde Verzögerung einmal in 3 Sekunden ausführen: 1518013028
Nach 1 Sekunde Verzögerung einmal in 3 Sekunden ausführen: 1518013031

4.Nesinglethreadexecutor erstellt einen Thread-Pool mit einem Thread, der nur Arbeitsthreads verwendet, um Aufgaben auszuführen, um die Reihenfolge sicherzustellen. Das Beispiel ist wie folgt

 ExecutorService SinglethreadExecutor = Executors.NewsingLethreadExecutor (); für (int i = 0; i <10; i ++) {endgültig int index = i; Singlethreadexecutor.execute (new Runnable () {@Override public void run () {try {system.out.println (Thread.CurrentThread (). getName () + "," + Index); Thread.sleep (2000);

Konsoleninformationen
Pool-1-Thread-1,0
Pool-1-Thread-1,1
Pool-1-Thread-1,2
Pool-1-Thread-1,3
Pool-1-Thread-1,4

Senden Sie Aufgaben zum Thread -Pool. Der Unterschied zwischen Execute () und Subjekt () in der ThreadPoolexecutor -Klasse ist tatsächlich eine Methode, die in Executor deklariert wurde. Es ist in ThreadPoolexecutor implementiert. Diese Methode ist die Kernmethode des ThreadPoolexecutors. Über diese Methode kann eine Aufgabe an den Thread -Pool übermittelt und zur Ausführung an den Thread -Pool übergeben werden.

Die Methode subjekt () ist eine im Executorservice deklarierte Methode. Es wurde in der AbstractExecutorService implementiert. Es wird im ThreadPoolexecutor nicht umgeschrieben. Diese Methode wird auch verwendet, um Aufgaben an den Thread -Pool zu übermitteln. Es unterscheidet sich jedoch von der methodischen Methode execute (). Es kann das Ergebnis der Aufgabenausführung zurückgeben. Überprüfen Sie die Implementierung der Methode subjekt () über den Quellcode, und Sie werden feststellen, dass es sich tatsächlich um die ausgeführte () -Methode bezeichnet wird. Sie verwendet jedoch zukünftig, um das Ausführungsergebnis der Aufgabe zu erhalten.

 /** * @throws rejecedexecutionException {@inheritdoc} * @throws nullPointerException {@inheritdoc} */public Future <?> suble (runnable task) {if (task == null). RunnableFuture <void> ftask = newtaskfor (Aufgabe, null); ausführen (ftask); ftask zurückgeben;}

Schließen des Thread -Pools Wir können den Thread -Pool schließen, indem Sie die Herunterfahren- oder Herunterfahren des Thread -Pools aufrufen. Die Implementierungsprinzipien sind jedoch unterschiedlich. Das Herunterfahren besteht darin, den Status des Thread -Pools einfach auf den Stillstand zu setzen und dann alle Threads zu unterbrechen, die keine Aufgaben ausführen. Das Prinzip des Herunterfahrens besteht darin, die Worker -Threads im Thread -Pool zu durchqueren und dann die Interrupt -Methode des Threads nach dem anderen zu rufen, um den Thread zu unterbrechen, sodass Aufgaben, die auf Interrupts nicht reagieren können, niemals beendet werden können. Shutdownnow setzt zunächst den Status des Thread -Pools, um zu stoppen, dann versuchen Sie, alle Threads zu stoppen, die Aufgaben ausführen oder innehalten, und kehren zur Liste der Warten auf die Ausführung von Aufgaben zurück.

Solange eine dieser beiden Abschlussmethoden aufgerufen wird, wird die ISShutdown -Methode wahr zurückgegeben. Wenn alle Aufgaben geschlossen wurden, bedeutet dies, dass der Fadenpool erfolgreich geschlossen ist. Das Aufrufen der IS -termined -Methode wird true zurückkehren. Wie für welche Methode wir anrufen sollten, um den Thread -Pool zu schließen, sollte er durch die dem Thread Pool eingereichten Aufgabenmerkmale festgelegt werden. Normalerweise wird das Abschalten aufgerufen, um den Fadenpool zu schließen. Wenn die Aufgabe nicht ausgeführt werden muss, kann das Shutdownnow aufgerufen werden.

3.. Analyse des Threadpools

Prozessanalyse: Der Hauptworkflow des Threadpool

Aus der obigen Abbildung können wir sehen, dass der Verarbeitungsfluss des Thread -Pools bei der Übermittlung einer neuen Aufgabe an den Thread -Pool wie folgt lautet:

1. Erstens bestimmt der Thread -Pool, ob der Basis -Thread -Pool voll ist? Nicht voll, erstellen Sie einen Worker -Thread, um die Aufgabe auszuführen. Geben Sie in vollem Umfang den nächsten Prozess ein.
2. Zweitens bestimmt der Thread -Pool, ob die Arbeitswarteschlange voll ist? Wenn nicht voll, werden die neu eingereichten Aufgaben in der Arbeitswarteschlange gespeichert. Geben Sie in vollem Umfang den nächsten Prozess ein.
3. Schließlich bestimmt der Thread -Pool, ob der gesamte Threadpool voll ist? Wenn es nicht voll ist, wird ein neuer Worker -Thread erstellt, um die Aufgabe auszuführen. Wenn es voll ist, wird es der Sättigungsrichtlinie übergeben, um die Aufgabe zu erledigen.

** Quellcodeanalyse. ** Die obige Prozessanalyse ermöglicht es uns, das Arbeitsprinzip von Threadpools intuitiv zu verstehen. Verwenden wir den Quellcode, um zu sehen, wie er implementiert wird. Der Thread -Pool führt Aufgaben wie folgt aus:

 public void execute (runnable command) {if (command == null) werfen neue nullpointerexception (); int c = ctl.get (); if (WorkerCountOf (c) <corepoolSize) {if (Addworker (Befehl, true)) return; c = ctl.get (); } if (isrunning (c) && workQueue.offer (Befehl)) {int recheck = ctl.get (); if (! isrunning (neu überprüfen) && entfernen (Befehl)) ablehnen (Befehl); sonst if (WorkerCountof (Rechock) == 0) Addworker (null, false); } else if (! Addworker (Befehl, falsch)) ablehnen (Befehl);}

Arbeiter Thread. Wenn ein Thread -Pool einen Thread erstellt, wird der Thread in einen Worker -Thread zusammengefasst. Nachdem der Arbeiter die Aufgabe ausgeführt hat, wird es auch unendlich unendlich geschaltet, Aufgaben in der Arbeitswarteschlange zur Ausführung zu erhalten.

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.