CKTIS / Java
Threadpools met een vaste grootte, wachtrijcapaciteit en ordelijk afsluiten
Maak twee pools met elk twee workerthreads, vergelijk hun wachtrijlimieten en haal de resultaten op voordat je beide pools afsluit met `shutdown()`.
Versie: 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 geeft de statische methode Executors.newFixedThreadPool(2) uit java.util.concurrent een ExecutorService terug die workerthreads hergebruikt. Er verwerken maximaal twee workers tegelijk taken. Als beide bezet zijn, wachten extra taken in een gedeelde wachtrij zonder ingestelde capaciteitslimiet. Een limiet op het aantal workers begrenst dus niet het aantal wachtende taken. Als taken sneller binnenkomen dan de pool ze afrondt, kan de wachtrij groeien en meer geheugen gebruiken.
De overload Executors.newFixedThreadPool(nThreads, threadFactory) maakt workers met de opgegeven ThreadFactory, maar begrenst de wachtrij niet. Beide overloads werpen een IllegalArgumentException bij nThreads <= 0; de tweede werpt een NullPointerException als de factory null is.
Om het aantal wachtende taken te begrenzen, configureer je een ThreadPoolExecutor met zowel de kerngrootte als de maximumgrootte op 2 en een ArrayBlockingQueue<>(2). Zo kunnen maximaal twee taken op workers draaien en maximaal twee andere in de wachtrij staan. Kan de pool geen taak aannemen doordat beide workers bezet zijn en de wachtrij vol is, dan werpt AbortPolicy een RejectedExecutionException in plaats van op ruimte te wachten. Het beleid wijst ook taken af die na het begin van de afsluiting worden ingediend.
ExecutorService.shutdown() legt het contract voor ordelijk afsluiten vast en ThreadPoolExecutor.shutdown() voert het uit: eerder aangenomen taken kunnen worden uitgevoerd, nieuwe worden geweigerd en de aanroep wacht niet op voltooiing. Opnieuw aanroepen heeft geen extra effect. Als een actieve securitymanager geen toestemming geeft, kan een SecurityException optreden. Haal bij normaal verloop alle benodigde resultaten op met Future.get() voordat je beide pools afsluit in finally, dat ook bij een fout wordt uitgevoerd. get() wacht zo nodig op één taak; gebruik na shutdown() de methode awaitTermination() om met een tijdslimiet te wachten tot de hele pool is beëindigd.
Voorbeelden
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();
}
}
}
}Resultaat
fixed=5, bounded=12
Het programma dient bij elke pool twee taken in en haalt bij normaal verloop alle vier de resultaten op vóór het afsluiten. Het drukt alleen de twee sommen af, één per pool, in een vaste volgorde, ongeacht de planning van de threads. Het voorbeeld forceert geen volle wachtrij of taakweigering.
Gerelateerde lessen
- Java · Les 42 · Gevorderd · Versie: 2
Bronnen
- 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()