Java Concurrency Package: Vier Thread-Pools, die von Java über Executors bereitgestellt werden

Java's vier Thread-Pools newCachedThreadPool, newFixedThreadPool, newScheduledThreadPool, newSingleThreadExecutor

Nachteile von neuen Threads

Die Leistung neuer Objekte, die jedes Mal neu erstellt werden Der Thread ist schlecht.
b. Threads fehlt eine einheitliche Verwaltung, es kann unbegrenzt neue Threads geben, sie konkurrieren miteinander und belegen möglicherweise zu viele Systemressourcen, was zu Abstürzen oder OOM führt.
c. Fehlen weiterer Funktionen, wie z. B. geplante Ausführung, periodische Ausführung und Thread-Unterbrechung.
Im Vergleich zu neuen Threads bieten die vier von Java bereitgestellten Thread-Pools folgende Vorteile:
a. Wiederverwendung vorhandener Threads, Reduzierung der Kosten für die Objekterstellung und -zerstörung und gute Leistung.
b. Es kann die maximale Anzahl gleichzeitiger Threads effektiv steuern, die Nutzung von Systemressourcen verbessern und übermäßigen Ressourcenwettbewerb und Überlastung vermeiden.
c. Bietet Funktionen wie geplante Ausführung, periodische Ausführung, Einzelthread und Parallelitätskontrolle.

Java stellt über Executors vier Thread-Pools bereit:
newCachedThreadPool erstellt einen zwischenspeicherbaren Thread-Pool. Wenn die Länge des Thread-Pools den Verarbeitungsbedarf übersteigt, können inaktive Threads flexibel recycelt werden , erstelle einen neuen Thread.
newFixedThreadPool erstellt einen Thread-Pool mit fester Länge, der die maximale Anzahl gleichzeitiger Threads steuern kann, die in der Warteschlange warten.
newScheduledThreadPool erstellt einen Thread-Pool fester Länge, der die geplante und periodische Aufgabenausführung unterstützt.
newSingleThreadExecutor erstellt einen Single-Threaded-Thread-Pool, der nur einen eindeutigen Arbeitsthread zum Ausführen von Aufgaben verwendet und sicherstellt, dass alle Aufgaben in der angegebenen Reihenfolge (FIFO, LIFO, Priorität) ausgeführt werden.

(1). newCachedThreadPool
Erstellen Sie einen zwischenspeicherbaren Thread-Pool, der den Verarbeitungsbedarf übersteigt, und inaktive Threads können flexibel recycelt werden. Wenn keine weiteren vorhanden sind, wird beim Recycling ein neuer Thread erstellt. Der Beispielcode lautet wie folgt:

ExecutorService cachedThreadPool = Executors.newCachedThreadPool();for (int i = 0; i < 10; i++) {final int index = i;try {Thread.sleep(index * 1000);} catch (InterruptedException e) {e.printStackTrace();} cachedThreadPool.execute(new Runnable() { @Overridepublic void run() {System.out.println(in
dex);}});}

Der Thread-Pool ist unendlich. Wenn die zweite Aufgabe ausgeführt wird, ist die erste Aufgabe abgeschlossen und der Thread, der die erste Aufgabe ausführt, wird wiederverwendet, anstatt einen neuen Thread zu erstellen jedesmal.

(2). newFixedThreadPool
Erstellt einen Thread-Pool mit fester Länge, der die maximale Anzahl gleichzeitiger Threads steuern kann, die in der Warteschlange warten. Der Beispielcode lautet wie folgt:

ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
for (int i = 0; i < 10; i++) {
final int index = i;
fixedThreadPool.execute(new Runnable() {
 
@Override
public void run() {
try {
System.out.println(index);
Thread.sleep(2000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
});
}

Da die Thread-Pool-Größe 3 beträgt, schläft jede Aufgabe nach der Ausgabe des Index 2 Sekunden lang, sodass alle zwei Sekunden 3 Zahlen gedruckt werden.

Die Größe des Thread-Pools fester Länge wird am besten entsprechend den Systemressourcen festgelegt. Wie zum Beispiel Runtime.getRuntime().availableProcessors(). Weitere Informationen finden Sie unter PreloadDataCache.

(3) newScheduledThreadPool
Erstellen Sie einen Thread-Pool fester Länge, um die geplante und periodische Aufgabenausführung zu unterstützen. Der Beispielcode für die verzögerte Ausführung lautet wie folgt: ScheduledExecutorService failedThreadPool =

Executors.newScheduledThreadPool(5);
scheduledThreadPool.schedule(new Runnable() {
 
@Override
public void run() {
System.out.println("delay 3 seconds");
}
}, 3, TimeUnit.SECONDS);

bedeutet verzögerte Ausführung um 3 Sekunden.

Der Beispielcode für die reguläre Ausführung lautet wie folgt:

scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
 
@Override
public void run() {
System.out.println("delay 1 seconds, and excute every 3 seconds");
}
}, 1, 3, TimeUnit.SECONDS);

bedeutet die Ausführung alle 3 Sekunden nach einer Verzögerung von 1 Sekunde.

ScheduledExecutorService ist sicherer und leistungsfähiger als Timer. Zum Vergleich wird es später einen separaten Artikel geben.

(4), newSingleThreadExecutor
Erstellen Sie einen Single-Threaded-Thread-Pool, der nur den einzigen Arbeitsthread zum Ausführen von Aufgaben verwendet, um sicherzustellen, dass alle Aufgaben in der angegebenen Reihenfolge sind ( Ausführung (FIFO, LIFO, Priorität). Der Beispielcode lautet wie folgt:

ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
for (int i = 0; i < 10; i++) {
final int index = i;
singleThreadExecutor.execute(new Runnable() {
 
@Override
public void run() {
try {
System.out.println(index);
Thread.sleep(2000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
});
}

Die Ergebnisse werden nacheinander ausgegeben, was der Ausführung jeder Aufgabe nacheinander entspricht.

Die meisten aktuellen GUI-Programme sind Single-Threaded. Einzelne Threads in Android können für Datenbankvorgänge, Dateivorgänge, Stapelinstallationen von Anwendungen, Stapellöschungen von Anwendungen und andere Vorgänge verwendet werden, die nicht für die Parallelität geeignet sind, aber zu E/A-Blockierungen führen und die Reaktion des UI-Threads beeinträchtigen können.

Die Rolle des Thread-Pools:

Die Rolle des Thread-Pools besteht darin, die Anzahl der Ausführungsthreads im System zu begrenzen.
Je nach Systemumgebung kann die Anzahl der Threads automatisch oder manuell eingestellt werden, um den besten Betriebseffekt zu erzielen. Weniger verschwendet Systemressourcen und mehr führt zu Systemüberlastung und Ineffizienz. Verwenden Sie den Thread-Pool, um die Anzahl der Threads zu steuern, und andere Threads warten in der Schlange. Nachdem eine Aufgabe ausgeführt wurde, wird die vorderste Aufgabe in der Warteschlange übernommen und mit der Ausführung begonnen. Wenn sich in der Warteschlange kein Warteprozess befindet, wartet diese Ressource des Thread-Pools. Wenn eine neue Aufgabe ausgeführt werden muss und sich im Thread-Pool wartende Arbeitsthreads befinden, kann sie mit der Ausführung beginnen. Andernfalls gelangt sie in die Warteschlange.

Warum Thread-Pool verwenden:

1. Reduzieren Sie die Anzahl der Thread-Erstellung und -Zerstörung, jeder Arbeitsthread kann wiederverwendet werden und mehrere Aufgaben ausführen.

2. Sie können die Anzahl der Arbeitsthreads im Thread-Pool entsprechend der Kapazität des Systems anpassen, um zu verhindern, dass der Server aufgrund übermäßigen Speicherverbrauchs erschöpft wird (jeder Thread benötigt etwa 1 MB Speicher und der Thread startet). Je mehr Speicher verbraucht wird, desto mehr Speicher wird verbraucht und schließlich stürzt das System ab.

Die Schnittstelle der obersten Ebene des Thread-Pools in Java ist Executor, aber streng genommen ist Executor kein Thread-Pool, sondern lediglich ein Tool zum Ausführen von Threads. Die eigentliche Thread-Pool-Schnittstelle ist ExecutorService.

Verwandte Artikel:

Detaillierte Erläuterung des grafischen Codes des Thread-Pools in Java

Detaillierte Erläuterung der Verwendung des Thread-Pools in Java gleichzeitige Programmierung

Ähnliche Videos:

Video-Tutorial für fortgeschrittene Java-Multithreading- und Parallelitätsbibliotheken für Anwendungen

Das obige ist der detaillierte Inhalt vonJava Concurrency Package: Vier Thread-Pools, die von Java über Executors bereitgestellt werden. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!