Java erklärt ThreadPool-Thread-Pool

ThreadPool-Thread-Pool

• 1. Vorteile des Thread-Pools
• 1.2. Warum Thread-Pool verwenden
  2.1. Architektur Beschreibung: 2.2. Drei Hauptmethoden des Thread-Pools ecutor zugrunde liegendes Prinzip
4. Sieben wichtige Parameter des Thread-Pools
• (Verwandte kostenlose Lernempfehlungen:
  Basic Java Tutorial)
  • 1. Vorteile des Thread-Pools
  • ist dem Datenbank-Thread-Pool ähnlich. Wenn kein Datenbankverbindungspool vorhanden ist, ist jedes Mal „new“ erforderlich, um den Verbindungspool für die Datenbank abzurufen. Wiederholte Verbindungs- und Freigabevorgänge verbrauchen viele Systemressourcen. Wir können den Datenbankverbindungspool verwenden und den Verbindungspool direkt aus dem Pool abrufen.
    • Ebenso haben wir, bevor es einen Thread-Pool gab, Threads über new Thread.start() erhalten. Jetzt brauchen wir keine neuen, sodass wir eine Wiederverwendung erreichen und unser System effizienter machen können.
    • 1.2. Warum Thread-Pool verwenden? Beispiel:
    Vor 10 Jahren ein Single-Core-CPU-Computer, gefälschtes Multithreading, wie ein Zirkusclown, der mit mehreren Bällen spielt, die CPU muss hin und her wechseln.
  Heutzutage handelt es sich um einen Multi-Core-Computer, der auf unabhängigen CPUs ausgeführt wird, was ohne Umschalten effizienter ist.
• Vorteile des Thread-Pools:

Der Thread-Pool steuert lediglich die Anzahl der laufenden Threads, stellt Aufgaben während der Verarbeitung in die Warteschlange und startet diese Aufgaben dann, nachdem die Threads erstellt wurden Wenn die Anzahl der Threads die maximale Anzahl überschreitet, warten Threads, die die Anzahl überschreiten, in der Warteschlange, warten darauf, dass andere Threads die Ausführung abschließen, und nehmen dann die Aufgabe zur Ausführung aus der Warteschlange.

Seine Hauptfunktionen sind:

Thread-Wiederverwendung

Kontrollieren Sie die maximale Anzahl von Parallelität

Verwalten Sie Threads

Vorteile:

• Erstens: Reduzieren Sie den Ressourcenverbrauch. Reduzieren Sie den durch die Thread-Erstellung und -Zerstörung verursachten Overhead, indem Sie bereits erstellte Threads wiederverwenden.

Zweitens: Reaktionsgeschwindigkeit verbessern. Wenn eine Aufgabe eintrifft, kann die Aufgabe sofort ausgeführt werden, ohne auf die Thread-Erstellung warten zu müssen.

Drittens: Verbessern Sie die Thread-Verwaltbarkeit. Threads sind knappe Ressourcen. Wenn sie ohne Einschränkungen erstellt werden, verbrauchen sie nicht nur Systemressourcen, sondern verringern auch die Stabilität des Systems. Der Thread-Pool kann für eine einheitliche Zuordnung, Optimierung und Überwachung verwendet werden.

2. Verwendung des Thread-Pools
2.1 Architekturbeschreibung
Was ist das Executor-Framework?
• Dies wird im Java Doc beschrieben.

Ein Objekt, das übermittelte ausführbare Aufgaben ausführt. Diese Schnittstelle bietet eine Möglichkeit, die Aufgabenübermittlung von der Mechanik zu entkoppeln, wie jede Aufgabe ausgeführt wird, einschließlich Details zur Thread-Nutzung, Planung usw. An Der Executor wird normalerweise anstelle der expliziten Erstellung von Threads verwendet.

Ein Objekt, das übermittelte ausführbare Aufgaben ausführt
• . Diese Schnittstelle bietet einen Mechanismus zum Senden von Aufgaben und zum Ausführen jeder Aufgabe, einschließlich Details zur Thread-Nutzung, Planung usw. Es ist üblich, einen Executor zu verwenden, anstatt explizit Threads zu erstellen. Der Thread-Pool in Java wird über das Executor-Framework implementiert, das die Klassen Executor, Executors, ExecutorService und ThreadPoolExecutor verwendet.
Die Schnittstelle, die wir üblicherweise verwenden, ist die ExecutorService-Unterschnittstelle
• , Executoren sind Werkzeugklassen für Threads (Werkzeugklassen ähnlich Arrays, Arrays und Sammlungswerkzeugklassen, Sammlungen).
ThreadPoolExecutor steht im Mittelpunkt dieser Klassen
• . Wir können den ThreadPoolExecutor-Thread-Pool über die Hilfstoolklasse Executors abrufen

Eine detailliertere Einführung in jede Klasse lautet wie folgt:

Executor verfügt nur über eine Methode für alle Thread-Pool-Schnittstellen, die die Art und Weise definiert, wie Runnable ausgeführt wird Aufgaben

ExecutorService fügt das Verhalten von Executor hinzu und ist die direkteste Schnittstelle der Executor-Implementierungsklasse. Die Schnittstellendefinition stellt Dienste für die Thread-Pool-Factory-Klasse Executor bereit, die eine Reihe von Factory-Methoden zum Erstellen von Thread-Pools bereitstellt Zurückgegebene Thread-Pools sind implementiert

ScheduledExecutorService: Schnittstelle für geplante Planung. AbstractExecutorService-Ausführungsframework-Abstraktklasse.

ThreadPoolExecutor Die spezifische Implementierung des Thread-Pools im JDK. Basierend auf dieser Klasse werden verschiedene häufig verwendete Thread-Pools implementiert.

2.2. Drei Hauptmethoden des Thread-Pools

Exectors.newFixedThreadPool(int) -->Gute Leistung bei der Ausführung langfristiger Aufgaben. Jeder Pool hat N feste Threads und eine feste Anzahl von Threads

	public static void main(String[] args) {
		//一池5个受理线程，类似一个银行5个受理窗口。不管你现在多少个线程，都只有5个
		ExecutorService threadPool=Executors.newFixedThreadPool(5); 
		
		try {
			//模拟有10个顾客过来银行办理业务，目前池子里面有5个工作人员提供服务。
			for(int i=1;i{
					System.out.println(Thread.currentThread().getName()+"\t 办理业务");
				});
			}
		} catch (Exception e) {
			// TODO: handle exception
		}finally{
			threadPool.shutdown();
		}	
	}

kann die Ausführungsergebnisse sehen. Es gibt 5 Threads im Pool, was 5 Mitarbeitern entspricht, die externe Dienstleistungen erbringen und Geschäfte abwickeln. Im Bild wickelt Fenster Nr. 1 Geschäfte zweimal ab, und das Annahmefenster der Bank kann mehrfach wiederverwendet werden. Es ist nicht unbedingt so, dass jeder es zweimal schafft, aber wer es schneller schafft, schafft mehr.

Wenn wir während der Thread-Ausführung eine Verzögerung von 400 ms hinzufügen, können wir den Effekt sehen

public static void main(String[] args) {
		//一池5个受理线程，类似一个银行5个受理窗口。不管你现在多少个线程，都只有5个
		ExecutorService threadPool=Executors.newFixedThreadPool(5); 
		
		try {
			//模拟有10个顾客过来银行办理业务，目前池子里面有5个工作人员提供服务。
			for(int i=1;i{
					System.out.println(Thread.currentThread().getName()+"\t 办理业务");
				});
				try {
					TimeUnit.MILLISECONDS.sleep(400);
				} catch (Exception e) {
					// TODO: handle exception
					e.printStackTrace();
				}
			}
		} catch (Exception e) {
			// TODO: handle exception
		}finally{
			threadPool.shutdown();
		}	
	}

Dies zeigt, dass der Thread-Pool Geschäftsaufgaben gleichmäßiger verarbeitet, wenn das Netzwerk überlastet oder die Geschäftsverarbeitung langsam ist.

2.2.2.Newsinglethreexector

exectors ;Führen Sie viele kurzfristige asynchrone Aufgaben aus. Der Thread-Pool erstellt nach Bedarf neue Threads, verwendet jedoch zuvor erstellte Threads wieder, sobald diese verfügbar sind. Es kann erweitert werden und wird stärker, wenn es stark ist

. Ein Pool mit n Threads kann erweitert, skaliert und zwischengespeichert werden.

Wie viele Pools sollten also festgelegt werden? Wenn die Bank nur ein Fenster hat, ist sie zu beschäftigt, wenn zu viele Leute kommen. Wenn eine Bank viele Fenster hat, aber nur wenige Leute kommen, wirkt das wie eine Verschwendung von Ressourcen. Wie kann man also vernünftige Vorkehrungen treffen? Dies erfordert die Verwendung der methodischen Methode von Newcached threadpool (), die erweitert und skalierbar ist. Zu den zugrunde liegenden Parametern gehört die Blockierungswarteschlange LinkedBlocking.

newSingleThreadExecutor zugrunde liegender Quellcode

public static void main(String[] args) {
	//一池一个工作线程，类似一个银行有1个受理窗口
	ExecutorService threadPool=Executors.newSingleThreadExecutor(); 	
	try {
		//模拟有10个顾客过来银行办理业务
		for(int i=1;i{
				System.out.println(Thread.currentThread().getName()+"\t 办理业务");
			});
		}
	} catch (Exception e) {
		// TODO: handle exception
	}finally{
		threadPool.shutdown();
	}	}

newCachedThreadPool zugrunde liegender Quellcode

public static void main(String[] args) {
		//一池一个工作线程，类似一个银行有n个受理窗口
		ExecutorService threadPool=Executors.newCachedThreadPool(); 	
		try {
			//模拟有10个顾客过来银行办理业务
			for(int i=1;i{
					System.out.println(Thread.currentThread().getName()+"\t 办理业务");
				});
			}
		} catch (Exception e) {
			// TODO: handle exception
		}finally{
			threadPool.shutdown();
		}	
	}

SynchronousQueue Diese Blockierungswarteschlange ist eine einzelne Version der Blockierungswarteschlange, und die Kapazität der Blockierungswarteschlange beträgt 1.

Tatsächlich geben diese drei Methoden alle zurück ein Objekt, nämlich ThreadPoolExecutor Object

.

4. Das Obige ist die Konstruktionsmethode der ThreadPoolExecutor-Klasse, die 7 Parameter hat:

1) corePoolSize: Die Anzahl der residenten Kernthreads im Thread-Pool , die als Anzahl der Kerne bezeichnet wird.

Beispielsweise können wir einen Thread-Pool wie eine Bankfiliale behandeln. Solange die Bank geöffnet ist, muss mindestens eine Person im Dienst sein. Dies wird als Anzahl der ansässigen Kern-Threads bezeichnet. Wenn eine Bank beispielsweise alle fünf Filialen von Montag bis Freitag geöffnet hat, beträgt die Anzahl der ansässigen Kernthreads von Montag bis Freitag 5. Wenn heute nicht so viele Geschäfte stattfinden und das Fenster 1 beträgt, beträgt die Anzahl der ansässigen Kernthreads heute ist 1

2)

maxImumPoolSize: Die maximale Anzahl von Threads, die gleichzeitig im Thread-Pool ausgeführt werden können. Dieser Wert muss größer oder gleich 1 sein

3)

keepAliveTime: Die Überlebenszeit überschüssiger Leerlauf-Threads . Wenn die Anzahl der Threads im aktuellen Pool corePoolSize überschreitet, werden überschüssige Threads zerstört, bis corePoolSize übrig ist und eine maximale Anzahl von Threads vorhanden ist Wenn die maximale Anzahl an Threads erreicht ist, werden normalerweise Threads verwendet. Wenn das Geschäft abnimmt, legen wir die Überlebenszeit der überschüssigen Threads fest, z. B. 30 Sekunden Für 30 Sekunden schließen einige Banken das Fenster, sodass es nicht nur expandiert, sondern auch schrumpft.

4)

Einheit: Einheit der KeepAliveTime

Einheit: Sekunden, Millisekunden, Mikrosekunden.

5) workQueue: Aufgabenwarteschlange, Aufgaben, die eingereicht, aber noch nicht ausgeführt wurden Dies ist eine Blockierungswarteschlange, zum Beispiel hat eine Bank nur 3 Annahmefenster und es sind 4 Kunden gekommen. Diese Sperrwarteschlange ist der Wartebereich der Bank. Sobald ein Kunde kommt, darf er nicht gehen. Die Anzahl der Fenster steuert die Anzahl gleichzeitiger Threads.

6)

threadFactory: Stellt die Thread-Factory dar, die Arbeitsthreads im Thread-Pool generiert. Sie wird zum Erstellen von Threads verwendet. Im Allgemeinen reicht die Standardeinstellung aus.

Threads werden alle einheitlich erstellt. Es gibt neue Threads im Thread-Pool, die von der Thread-Pool-Factory erzeugt werden.

7) Handler: Ablehnungsstrategie, die angibt, wie die Strategie zur Ausführung ausführbarer Anforderungen abgelehnt werden soll, wenn die aktuelle Warteschlange voll ist und der Arbeitsthread größer oder gleich der maximalen Anzahl von Threads im Thread-Pool (maximumPoolSize) ist

Beispielsweise herrscht heute in der Bank der höchste Kundenandrang. Alle drei Fenster sind voll und auch der Wartebereich ist voll. Wir haben uns nicht entschieden, weiterhin Leute zu rekrutieren, weil es nicht sicher war, also haben wir uns entschieden, dies höflich abzulehnen.

Im nächsten Abschnitt stellen wir das zugrunde liegende Funktionsprinzip des Thread-Pools vor

Verwandte Lernempfehlungen: Java-Grundlagen

Das obige ist der detaillierte Inhalt vonJava erklärt ThreadPool-Thread-Pool. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!