CKTIS / Java
Threadpools fester Größe, Warteschlangenkapazität und geordnetes Herunterfahren
Erstelle zwei Pools mit je zwei Worker-Threads, vergleiche ihre Warteschlangen und hole die Ergebnisse vor `shutdown()` für beide Pools ab.
Version: Java SE 21
Syntax
In java.util.concurrent:
public static ExecutorService Executors.newFixedThreadPool(int nThreads)
public static ExecutorService Executors.newFixedThreadPool(int nThreads, ThreadFactory threadFactory)
void ExecutorService.shutdown()
public void ThreadPoolExecutor.shutdown()
Bounded-queue alternative:
new ThreadPoolExecutor(2, 2, 0L, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<>(2), new ThreadPoolExecutor.AbortPolicy())In Java SE 21 liefert die statische Methode Executors.newFixedThreadPool(2) aus java.util.concurrent einen ExecutorService, der Worker-Threads wiederverwendet. Höchstens zwei Worker bearbeiten gleichzeitig Aufgaben. Sind beide beschäftigt, warten weitere Aufgaben in einer gemeinsamen Warteschlange ohne festgelegte Kapazitätsgrenze. Die Zahl der Worker begrenzt also nicht die Zahl der wartenden Aufgaben. Treffen Aufgaben schneller ein, als der Pool sie abschließt, kann die Warteschlange wachsen und mehr Speicher belegen.
Die Überladung Executors.newFixedThreadPool(nThreads, threadFactory) verwendet die übergebene ThreadFactory zum Erzeugen von Workern, begrenzt die Warteschlange aber nicht. Beide Überladungen lösen bei nThreads <= 0 eine IllegalArgumentException aus; die zweite löst eine NullPointerException aus, wenn die Factory null ist.
Um die Zahl der wartenden Aufgaben zu begrenzen, konfiguriere einen ThreadPoolExecutor mit Kern- und Maximalgröße 2 sowie einer ArrayBlockingQueue<>(2). So können bis zu zwei Aufgaben auf Workern laufen und bis zu zwei weitere in der Warteschlange warten. Kann der Pool keine Aufgabe annehmen, weil beide Worker beschäftigt sind und die Warteschlange voll ist, löst AbortPolicy eine RejectedExecutionException aus, statt auf Platz zu warten. Sie weist auch Aufgaben ab, die nach Beginn des Herunterfahrens eingereicht werden.
ExecutorService.shutdown() definiert den Vertrag für das geordnete Herunterfahren; ThreadPoolExecutor.shutdown() setzt ihn um: Bereits angenommene Aufgaben können ausgeführt werden, neue werden abgewiesen, und der Aufruf wartet nicht auf den Abschluss. Ein weiterer Aufruf ändert nichts. Verweigert ein aktiver Security Manager die Berechtigung, ist eine SecurityException möglich. Hole im Normalfall alle benötigten Ergebnisse mit Future.get() ab, bevor du beide Pools in finally herunterfährst. Der Block wird auch bei einem Fehler ausgeführt. get() wartet bei Bedarf auf eine einzelne Aufgabe; mit awaitTermination() kannst du nach shutdown() mit Zeitlimit auf das Ende des gesamten Pools warten.
Beispiele
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public class PoolDemo {
public static void main(String[] args)
throws InterruptedException, ExecutionException {
ExecutorService fixed = Executors.newFixedThreadPool(2);
ThreadPoolExecutor bounded = new ThreadPoolExecutor(
2, 2, 0L, TimeUnit.MILLISECONDS,
new ArrayBlockingQueue<>(2), new ThreadPoolExecutor.AbortPolicy());
try {
Future<Integer> first = fixed.submit(() -> 2);
Future<Integer> second = fixed.submit(() -> 3);
Future<Integer> third = bounded.submit(() -> 5);
Future<Integer> fourth = bounded.submit(() -> 7);
int fixedSum = first.get() + second.get();
int boundedSum = third.get() + fourth.get();
System.out.println("fixed=" + fixedSum + ", bounded=" + boundedSum);
} finally {
try {
fixed.shutdown();
} finally {
bounded.shutdown();
}
}
}
}Ergebnis
fixed=5, bounded=12
Das Programm reicht je zwei Aufgaben pro Pool ein und holt im Normalfall alle vier Ergebnisse vor dem Herunterfahren ab. Die Ausgabe hat unabhängig vom Thread-Scheduling eine feste Reihenfolge. Eine volle Warteschlange oder die Ablehnung einer Aufgabe wird nicht erzwungen.
Zugehörige Lektionen
- Java · Lektion 42 · Fortgeschritten · Version: 2
Quellen
- Executors (Java SE 21 & JDK 21) — newFixedThreadPool(int)
- Executors (Java SE 21 & JDK 21) — newFixedThreadPool(int, ThreadFactory)
- ExecutorService (Java SE 21 & JDK 21) — shutdown(), submit(), and awaitTermination()
- ThreadPoolExecutor (Java SE 21 & JDK 21) — queuing and task rejection
- ThreadPoolExecutor (Java SE 21 & JDK 21) — shutdown()
- ThreadPoolExecutor.AbortPolicy (Java SE 21 & JDK 21)
- ArrayBlockingQueue (Java SE 21 & JDK 21) — fixed queue capacity
- Future (Java SE 21 & JDK 21) — get()