CKTIS / Java
Executors.newFixedThreadPool — Threadpool mit fester Größe
Ein Pool der Größe 3 kann höchstens drei Aufgaben gleichzeitig bearbeiten. Sie müssen nicht zum selben Zeitpunkt beginnen. Sind alle Worker-Threads belegt, warten weitere Aufgaben in einer Warteschlange.
Version: Java SE 21
Syntax
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadFactory;
// Static methods declared by Executors:
public static ExecutorService newFixedThreadPool(int nThreads)
public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory)
// Example call:
ExecutorService pool = Executors.newFixedThreadPool(3);Executors.newFixedThreadPool ist eine statische Fabrikmethode der Klasse java.util.concurrent.Executors. Sie liefert einen ExecutorService, der seine Worker-Threads für weitere Aufgaben wiederverwendet. Mit Executors.newFixedThreadPool(3) können höchstens drei Aufgaben gleichzeitig in Bearbeitung sein. Das ist eine Obergrenze, keine Garantie für denselben Startzeitpunkt, echte parallele Ausführung oder einen Abschluss in Einreichungsreihenfolge.
Sind alle Worker-Threads belegt, warten weitere Aufgaben in einer gemeinsamen, unbeschränkten Warteschlange. Die Poolgröße begrenzt die Zahl der Worker-Threads, nicht die Zahl der wartenden Aufgaben. Kommen dauerhaft mehr Aufgaben hinzu, als der Pool abarbeitet, kann die Warteschlange immer mehr Speicher beanspruchen. Soll sie eine feste Obergrenze haben, verwende einen ThreadPoolExecutor mit beschränkter Warteschlange und einer bewusst gewählten Ablehnungsstrategie.
Die Überladung mit nur int nThreads nutzt die Standardfabrik, die Nicht-Daemon-Threads erzeugt. Die Überladung mit ThreadFactory nutzt die übergebene Fabrik, um bei Bedarf Worker-Threads zu erzeugen. Beide werfen bei nThreads <= 0 eine IllegalArgumentException; die zweite wirft außerdem eine NullPointerException, wenn die Fabrik null ist. Fällt vor dem Herunterfahren ein Worker-Thread aus, ersetzt ihn der Pool bei Bedarf, um spätere Aufgaben auszuführen.
Fahre den Pool herunter, wenn du ihn nicht mehr brauchst: Die Standard-Worker-Threads können die JVM am Leben halten. shutdown() nimmt keine neuen Aufgaben mehr an, lässt bereits eingereichte Aufgaben aber ausführen und wartet nicht auf das Ende des Pools. In Java SE 21 ruft try-with-resources close() auf. Diese Methode leitet das Herunterfahren ein und wartet, bis der Executor beendet ist.
Beispiele
import java.util.concurrent.Callable;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class FixedPoolDemo {
public static void main(String[] args)
throws InterruptedException, ExecutionException {
CountDownLatch started = new CountDownLatch(3);
CountDownLatch release = new CountDownLatch(1);
try (ExecutorService pool = Executors.newFixedThreadPool(3)) {
Callable<Void> holdWorker = () -> {
started.countDown();
release.await();
return null;
};
Future<Integer> fourth;
try {
for (int i = 0; i < 3; i++) {
pool.submit(holdWorker);
}
started.await();
fourth = pool.submit(() -> 4);
System.out.println("Fourth task done before release: " + fourth.isDone());
} finally {
release.countDown();
}
System.out.println("Fourth task result: " + fourth.get());
}
}
}Ergebnis
Fourth task done before release: false Fourth task result: 4
Jede der ersten drei Aufgaben belegt einen Worker-Thread und kann erst nach der Freigabe enden. Daher liefert `isDone()` für die vierte Aufgabe `false`. Nach der Freigabe wartet `get()` bei Bedarf auf das Ergebnis `4`. Das Beispiel zeigt eine zeitliche Überlappung, keinen Start zum selben Zeitpunkt.
Zugehörige Lektionen
- Java · Lektion 50 · Mittlere Stufe · Version: 2
Quellen
- Executors (Java SE 21 & JDK 21) — newFixedThreadPool(int)
- Executors (Java SE 21 & JDK 21) — newFixedThreadPool(int, ThreadFactory)
- Executors (Java SE 21 & JDK 21) — defaultThreadFactory()
- ExecutorService (Java SE 21 & JDK 21)
- ThreadPoolExecutor (Java SE 21 & JDK 21) — queuing and resource use
- CountDownLatch (Java SE 21 & JDK 21)
- Future (Java SE 21 & JDK 21)