Was sind die Prinzipien, Verwendungs- und Leistungsoptimierungsmethoden des Java-Thread-Pools?

1. Was sind Threads und Thread-Pools?

Threads sind die Grundeinheit der Zeitplanung im Betriebssystem.

Thread-Pool kann als Pool mit Threads verstanden werden, bei dem es sich um einen Container handelt. Dieser Container kann nur Threads enthalten. Dieser Behälter ist in verschiedenen Größen erhältlich und bietet Platz für 7 oder 8 Stück oder 3 oder 4 Stück. Der Behälter kann auch gefüllt werden, allerdings gibt es einen Maximalwert, beispielsweise 12. Beispielsweise enthält der Thread-Pool hier normalerweise 5 Threads und kann bis zu 12 Threads enthalten. Zu diesem Zeitpunkt mussten fünf Personen den Thread-Pool nutzen, also nahm er fünf Threads weg Es. Aber mein Pool kann 12 aufnehmen. Wie kann ich das machen, wenn ich nur 5 Threads habe? Ich muss unbedingt noch ein paar Threads installieren, sonst reicht es nicht, wenn es mehr Leute gibt. Zu diesem Zeitpunkt kamen 2 und ich produzierte 2. Die Gesamtzahl der Threads erreicht 7. Zu diesem Zeitpunkt müssen die verbleibenden 2 Personen nicht warten und können direkt verwendet werden. Wenn 6 Leute kommen, hat mein Pool zu diesem Zeitpunkt möglicherweise nur noch 5 Threads, aber es gibt immer noch eine Person, die irgendwo warten muss. Ich kann die Leute nicht ziellos warten lassen. Sie können dort sitzen und warten. Dann gehen der ersten Welle von fünf Threads die Fäden aus Zu diesem Zeitpunkt kamen 10 weitere Personen nacheinander. Der Sitzplatz kann nur noch von 4 Personen genutzt werden. Ich habe hier keinen Sitzplatz. Es ist auf jeden Fall unangenehm, Nein zu sagen, ohne vorher woanders zu suchen, und ich muss mir mehrere Ablehnungsstrategien überlegen. . . Ich denke, es gibt immer noch viele Leute, die meinen Thread-Pool nutzen. Was passiert, wenn jemand meinen Thread-Pool weiterhin belegt? Andernfalls kann ein Thread nur 1 Minute lang verwendet werden und wird sofort nach der Verwendung recycelt. Wenn Sie ihn erneut verwenden möchten, stellen Sie sich erneut in die Warteschlange. Auf diese Weise wird mein Thread-Geschäft immer besser. Solange es jemand nutzt, läuft es weiter.

Ist es nicht ein bisschen wie ein Restaurant oder ein Buffetladen? Solange es einen Sitzplatz in meinem Hotel gibt, können die restlichen Kunden nur Platz nehmen Warten Sie an der Tür. Ein Kunde kommt herein und der andere wartet draußen. Wenn es keinen Platz mehr gibt, wird der Kunde sofort gehen. sie können noch etwas warten. Kunden im Restaurant sollten nicht zu lange essen (normalerweise, wenn kein Sitzplatz frei ist), etwa 2 Stunden, und sie werden nach dem Essen gehen.

Anhand meiner obigen Beschreibung kann ich wahrscheinlich feststellen, was sich im Thread-Pool befindet?

Wie viele Threads sind installiert, wie viele Threads können installiert werden, wie lange Threads beibehalten werden können, Thread-Wartebereich, wie kann man ablehnen, Threads erstellen

1.1, warum Threads verwenden?

Das Programm muss ausgeführt werden Verlassen Sie sich auf den Prozess, den Prozess. Die eigentliche Ausführungseinheit ist der Thread.

• Aufruf von Diensten innerhalb des Systems. Das System ist auf die Ausführung von Prozessen angewiesen. Es gibt viele Dienste im System und es gibt Interaktionen zwischen Diensten. Die Ausführung von Diensten ist auf Threads angewiesen. Der Multi-Service-Betrieb basiert auf dem Multi-Thread-Betrieb. Die Aufrufe und der Datenaustausch zwischen Diensten sind für die Dateninteraktion auf den Speicher zwischen Prozessen angewiesen. Gleichzeitig können Threads auch ihren eigenen Speicherraum aufbauen. Verlassen Sie sich auf Ressourcenplanung und Dateninteraktion zwischen Prozessen.

• Mehrere Threads können die Ausführungsleistung des Programms verbessern. Wenn beispielsweise ein 90-Quadratmeter-Haus vorhanden ist, dauert die Reinigung durch eine Person 30 Minuten und durch drei Personen nur 10 Minuten. Diese drei Personen sind die „Multithreads“ im Programm.

In vielen Programmen müssen mehrere Threads miteinander synchronisiert werden oder sich gegenseitig ausschließen, um die Arbeit parallel abzuschließen.

Threads sind leichter als Prozesse, sodass die Kosten für das Erstellen und Zerstören von Threads geringer sind.

Threads verbessern die Leistung. Obwohl Threads makroskopisch parallel sind, sind sie mikroskopisch seriell. Aus CPU-Sicht können Threads die Leistung nicht verbessern. Wenn jedoch einige Threads auf Ressourcen warten (z. B. E/A, Warten auf Eingaben), ermöglicht Multithreading anderen Threads im Prozess die Fortsetzung der Ausführung, anstatt dass der gesamte Prozess blockiert wird Durch die Verbesserung der CPU-Auslastung wird die Leistung verbessert.

Bei Multi-CPU oder Multi-Core erfolgt die Verwendung von Threads nicht nur parallel auf der Makroebene, sondern auch auf der Mikroebene.

1.2. Warum Thread-Pool verwenden? Mehrere Threads können die Ausführungsleistung des Programms verbessern. Wenn beispielsweise genügend Sitzplätze und genügend Personen vorhanden sind, ist das Buffet am profitabelsten Gleichzeitig können auch die Essensrate und die Kundenzufriedenheit angegeben werden. Wenn 200 Personen essen und es 100 Essplätze gibt und jede Person durchschnittlich eine Stunde isst, dann sind die 200 Personen in zwei Stunden mit dem Essen fertig. Wenn es nur 10 Sitzplätze gibt, dauert es etwa 20 Stunden, bis 200 Personen essen. Denken Sie daran, wie unzufrieden die übrigen Kunden wären, wenn sie sehnsüchtig auf das Essen warten würden.

Die Sitzplätze im Buffet sind Fäden. Wenn es genügend Fäden gibt, kann es jedoch nicht heißen, dass es umso besser ist, je mehr Fäden vorhanden sind Kommen Sie jedes Mal zum Essen. Auch wenn 200 Kunden zum Essen kommen, müssen wir auch grundlegende Hardware-Faktoren bewerten, z. B. ob genügend Köche im Restaurant sind, ob die Putzfrau aufräumen kann und ob genügend Teller vorhanden sind Restaurant. Dies entspricht der Systemkonfiguration, die einige wesentliche Hardwarebedingungen wie Speicher und CPU-Verarbeitung erfordert.

Das Erstellen/Zerstören von Threads geht mit einem Systemaufwand einher, der sich stark auf die Verarbeitungseffizienz auswirkt (solange der Thread weiterhin ausgeführt wird, wird er nicht zerstört)

• Denken Sie daran, wie lange es dauert Um einen Thread T1 zu erstellen, kostet das Ausführen der Aufgabe Zeit T2, und das Zerstören des Threads kostet Zeit T3. Wenn T1+T3>T2, bedeutet das, dass es nicht kosteneffektiv ist, einen Thread zu öffnen, um diese Aufgabe auszuführen? Es ist einfach so, dass der Thread-Pool Threads zwischenspeichert und vorhandene inaktive Threads verwenden kann, um neue Aufgaben auszuführen, wodurch der durch T1 + T3 verursachte System-Overhead vermieden wird. Natürlich verbrauchen die verbleibenden Kern-Threads auch CPU-Ressourcen

Das gibt es auch Viele gleichzeitige Threads beanspruchen Systemressourcen und verursachen Blockaden

• Wenn zu viele Threads gleichzeitig ausgeführt werden, kann dies zu unzureichenden Systemressourcen führen und zur Blockierung führen kann die maximale Anzahl gleichzeitiger Threads effektiv steuern, um die oben genannten Probleme zu vermeiden

Führen Sie eine einfache Thread-Verwaltung durch

• Zum Beispiel: verzögerte Ausführung, zeitgesteuerte Schleifenausführungsstrategien usw. können mithilfe von Threads gut implementiert werden Pools

1.3, Thread-Pool Die Vorteile von

Thread-Nutzung verbessern

• Stellen Sie sicher, dass es verwendet wird, wenn Geschäfte vorhanden sind, und dass es freigegeben wird, wenn keine Geschäfte vorhanden sind. Verwenden Sie Threads rational und vermeiden Sie Ressourcenverschwendung.

Verbessern die Reaktionsgeschwindigkeit des Programms

• Durch die einheitliche Verwaltung des Thread-Pools wird die Ressourcenzuteilung mithilfe eines einheitlichen Planungspools geplant. Durch die Verwendung von Threads kann die zeitaufwändige Erstellung und Zerstörung von Threads vermieden werden direkt verwendet werden.

Erleichtert die einheitliche Verwaltung von Thread-Objekten.

• Der Thread-Pool kann eine einheitliche Zuordnung und Verwaltung von Threads gewährleisten.

Sie können die maximale Anzahl von Parallelitäten steuern

• Der Server hat eine Obergrenze für die Thread-Nutzung und die Thread-Nutzung verbraucht auch viele Ressourcen, sodass der Thread-Pool die Thread-Ressourcen sehr gut steuern kann, um Verschwendung zu vermeiden.

2. Die Verwendung des Thread-Pools in Java

ThreadPoolExecutor ist eine Thread-Pool-Klasse in Java, die zum Poolen von Threads verwendet werden kann.

// 根据上面的描述大概分析一下线程都需要什么及参数的解析
// corePoolSize 核心线程数，就是上面说的装了多少个线程
// maximumPoolSize 最大线程数，就是上面说的能装多少线程
// keepAliveTime 存活时间，就是上面说的线程可以保留多长时间
// TimeUnit 这个是时间单位，有时、分、秒、天等等，是存活时间的单位
// BlockingQueue<Runnable> 这是一个等待队列，就是上面显示的线程等待区
// ThreadFactory 线程工厂，就是上面描述的如何创建线程，由谁创建
// RejectedExecutionHandler 拒绝策略，就是上面显示的如何拒绝，是直接拒绝还是婉拒
public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
                          BlockingQueue<Runnable> workQueue)
public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory)
public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,RejectedExecutionHandler handler)
public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory,RejectedExecutionHandler handler)

Wie Sie sehen können, sind die folgenden Parameter erforderlich:

• corePoolSize (erforderlich): die Anzahl der Kernthreads. Standardmäßig bleibt der Kernthread immer bestehen, aber wenn „allowCoreThreadTimeout“ auf „true“ gesetzt ist, kommt es auch beim Kernthread zu einer Zeitüberschreitung und er wird recycelt.

• maximumPoolSize (erforderlich): Die maximale Anzahl von Threads, die der Thread-Pool aufnehmen kann. Wenn die Anzahl der aktiven Threads diesen Wert erreicht, werden nachfolgende neue Aufgaben blockiert.

• keepAliveTime (erforderlich): Thread-Leerlauf-Timeout. Wenn diese Zeit überschritten wird, werden Nicht-Kern-Threads recycelt. Wenn „allowCoreThreadTimeout“ auf „true“ gesetzt ist, kommt es auch für den Kernthread zu einer Zeitüberschreitung und er wird recycelt.

• unit (erforderlich): Gibt die Zeiteinheit für den keepAliveTime-Parameter an. Häufig verwendete sind: TimeUnit.MILLISECONDS (Millisekunden), TimeUnit.SECONDS (Sekunden), TimeUnit.MINUTES (Minuten).

• workQueue (erforderlich): Aufgabenwarteschlange. In diesem Parameter werden ausführbare Objekte gespeichert, die über die Methodeexecute() des Thread-Pools übermittelt werden. Es wird mithilfe einer Blockierungswarteschlange implementiert.

• threadFactory (optional): Thread-Factory. Wird verwendet, um anzugeben, wie neue Threads für den Thread-Pool erstellt werden.

• handler (optional): Ablehnungsstrategie. Eine Sättigungsstrategie, die ausgeführt werden muss, wenn die maximale Anzahl von Threads erreicht ist.

2.1. Funktionsprinzip des Thread-Pools

2.2. Java-Codebeispiel des Thread-Pools

import java.util.concurrent.*;
public class ThreadTest {
    public static void main(String[] args) {
        ExecutorService threadPoolExecutor = new ThreadPoolExecutor(3, 5, 1L, TimeUnit.SECONDS, new ArrayBlockingQueue<>(3), Executors.defaultThreadFactory());
        for (int i = 0; i < 20; i++) {
            int finalI = i;
            threadPoolExecutor.submit( ()->{
                System.out.println(Thread.currentThread().getName() + "========" + finalI);
            });
        }
        threadPoolExecutor.shutdown();
    }
}

Ausführungsergebnis:

pool-1-thread-1========0
pool-1-thread-3========2
pool-1-thread-3======= =4
Pool-1-Thread-2========1
Pool-1-Thread-3========5
Pool-1-Thread-2====== ==8
Pool-1-Thread-5========7
Pool-1-Thread-1========3
Pool-1-Thread-4===== ===6
Ausnahme im Thread „main“ java.util.concurrent.RejectedExecutionException: Aufgabe java.util.concurrent.FutureTask@61e717c2 abgelehnt von java.util.concurrent.ThreadPoolExecutor@66cd51c3[Wird ausgeführt, Poolgröße = 5, aktive Threads = 2, Aufgaben in der Warteschlange = 0, abgeschlossene Aufgaben = 7]
bei java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution(ThreadPoolExecutor.java:2063)
bei java.util.concurrent.ThreadPoolExecutor.reject(ThreadPoolExecutor.java:830 )
bei java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:1379)
bei java.util.concurrent.AbstractExecutorService.submit(AbstractExecutorService.java:112)
bei com.halo.communication.ThreadTest.main(ThreadTest .java:10)线程执行，然后开始出现异常处理。上面执行的线程数到thread-5，5是线程池的默认最大线程数.然后执行for循环20次,进行执行到8的时候出现异常,说明线程池已经超载满负荷执行，所以线程池执行拒绝策略.

Das obige ist der detaillierte Inhalt vonWas sind die Prinzipien, Verwendungs- und Leistungsoptimierungsmethoden des Java-Thread-Pools?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!